1 // $ANTLR 3.5 /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g 2015-04-23 12:35:16 2 3 package org.jf.smali; 4 5 import org.jf.dexlib2.Format; 6 import org.jf.dexlib2.Opcode; 7 import org.jf.dexlib2.Opcodes; 8 9 10 import org.antlr.runtime.*; 11 import java.util.Stack; 12 import java.util.List; 13 import java.util.ArrayList; 14 15 import org.antlr.runtime.tree.*; 16 17 18 @SuppressWarnings("all") 19 public class smaliParser extends Parser { 20 public static final String[] tokenNames = new String[] { 21 "<invalid>", "<EOR>", "<DOWN>", "<UP>", "ACCESS_SPEC", "ANNOTATION_DIRECTIVE", 22 "ANNOTATION_VISIBILITY", "ARRAY_DATA_DIRECTIVE", "ARRAY_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_LAMBDA", 35 "INSTRUCTION_FORMAT21c_METHOD", "INSTRUCTION_FORMAT21c_STRING", "INSTRUCTION_FORMAT21c_TYPE", 36 "INSTRUCTION_FORMAT21ih", "INSTRUCTION_FORMAT21lh", "INSTRUCTION_FORMAT21s", 37 "INSTRUCTION_FORMAT21t", "INSTRUCTION_FORMAT22b", "INSTRUCTION_FORMAT22c_FIELD", 38 "INSTRUCTION_FORMAT22c_FIELD_ODEX", "INSTRUCTION_FORMAT22c_STRING", "INSTRUCTION_FORMAT22c_TYPE", 39 "INSTRUCTION_FORMAT22cs_FIELD", "INSTRUCTION_FORMAT22s", "INSTRUCTION_FORMAT22s_OR_ID", 40 "INSTRUCTION_FORMAT22t", "INSTRUCTION_FORMAT22x", "INSTRUCTION_FORMAT23x", 41 "INSTRUCTION_FORMAT25x", "INSTRUCTION_FORMAT30t", "INSTRUCTION_FORMAT31c", 42 "INSTRUCTION_FORMAT31i", "INSTRUCTION_FORMAT31i_OR_ID", "INSTRUCTION_FORMAT31t", 43 "INSTRUCTION_FORMAT32x", "INSTRUCTION_FORMAT35c_METHOD", "INSTRUCTION_FORMAT35c_METHOD_ODEX", 44 "INSTRUCTION_FORMAT35c_TYPE", "INSTRUCTION_FORMAT35mi_METHOD", "INSTRUCTION_FORMAT35ms_METHOD", 45 "INSTRUCTION_FORMAT3rc_METHOD", "INSTRUCTION_FORMAT3rc_METHOD_ODEX", "INSTRUCTION_FORMAT3rc_TYPE", 46 "INSTRUCTION_FORMAT3rmi_METHOD", "INSTRUCTION_FORMAT3rms_METHOD", "INSTRUCTION_FORMAT51l", 47 "INTEGER_LITERAL", "INVALID_TOKEN", "I_ACCESS_LIST", "I_ANNOTATION", "I_ANNOTATIONS", 48 "I_ANNOTATION_ELEMENT", "I_ARRAY_ELEMENTS", "I_ARRAY_ELEMENT_SIZE", "I_CATCH", 49 "I_CATCHALL", "I_CATCHES", "I_CLASS_DEF", "I_ENCODED_ARRAY", "I_ENCODED_ENUM", 50 "I_ENCODED_FIELD", "I_ENCODED_METHOD", "I_END_LOCAL", "I_EPILOGUE", "I_FIELD", 51 "I_FIELDS", "I_FIELD_INITIAL_VALUE", "I_FIELD_TYPE", "I_IMPLEMENTS", "I_LABEL", 52 "I_LINE", "I_LOCAL", "I_LOCALS", "I_METHOD", "I_METHODS", "I_METHOD_PROTOTYPE", 53 "I_METHOD_RETURN_TYPE", "I_ORDERED_METHOD_ITEMS", "I_PACKED_SWITCH_ELEMENTS", 54 "I_PACKED_SWITCH_START_KEY", "I_PARAMETER", "I_PARAMETERS", "I_PARAMETER_NOT_SPECIFIED", 55 "I_PROLOGUE", "I_REGISTERS", "I_REGISTER_LIST", "I_REGISTER_RANGE", "I_RESTART_LOCAL", 56 "I_SOURCE", "I_SPARSE_SWITCH_ELEMENTS", "I_STATEMENT_ARRAY_DATA", "I_STATEMENT_FORMAT10t", 57 "I_STATEMENT_FORMAT10x", "I_STATEMENT_FORMAT11n", "I_STATEMENT_FORMAT11x", 58 "I_STATEMENT_FORMAT12x", "I_STATEMENT_FORMAT20bc", "I_STATEMENT_FORMAT20t", 59 "I_STATEMENT_FORMAT21c_FIELD", "I_STATEMENT_FORMAT21c_LAMBDA", "I_STATEMENT_FORMAT21c_METHOD", 60 "I_STATEMENT_FORMAT21c_STRING", "I_STATEMENT_FORMAT21c_TYPE", "I_STATEMENT_FORMAT21ih", 61 "I_STATEMENT_FORMAT21lh", "I_STATEMENT_FORMAT21s", "I_STATEMENT_FORMAT21t", 62 "I_STATEMENT_FORMAT22b", "I_STATEMENT_FORMAT22c_FIELD", "I_STATEMENT_FORMAT22c_STRING", 63 "I_STATEMENT_FORMAT22c_TYPE", "I_STATEMENT_FORMAT22s", "I_STATEMENT_FORMAT22t", 64 "I_STATEMENT_FORMAT22x", "I_STATEMENT_FORMAT23x", "I_STATEMENT_FORMAT25x", 65 "I_STATEMENT_FORMAT30t", "I_STATEMENT_FORMAT31c", "I_STATEMENT_FORMAT31i", 66 "I_STATEMENT_FORMAT31t", "I_STATEMENT_FORMAT32x", "I_STATEMENT_FORMAT35c_METHOD", 67 "I_STATEMENT_FORMAT35c_TYPE", "I_STATEMENT_FORMAT3rc_METHOD", "I_STATEMENT_FORMAT3rc_TYPE", 68 "I_STATEMENT_FORMAT51l", "I_STATEMENT_PACKED_SWITCH", "I_STATEMENT_SPARSE_SWITCH", 69 "I_SUBANNOTATION", "I_SUPER", "LINE_COMMENT", "LINE_DIRECTIVE", "LOCALS_DIRECTIVE", 70 "LOCAL_DIRECTIVE", "LONG_LITERAL", "MEMBER_NAME", "METHOD_DIRECTIVE", 71 "NEGATIVE_INTEGER_LITERAL", "NULL_LITERAL", "OPEN_BRACE", "OPEN_PAREN", 72 "PACKED_SWITCH_DIRECTIVE", "PARAMETER_DIRECTIVE", "PARAM_LIST_END", "PARAM_LIST_OR_ID_END", 73 "PARAM_LIST_OR_ID_START", "PARAM_LIST_START", "POSITIVE_INTEGER_LITERAL", 74 "PRIMITIVE_TYPE", "PROLOGUE_DIRECTIVE", "REGISTER", "REGISTERS_DIRECTIVE", 75 "RESTART_LOCAL_DIRECTIVE", "SHORT_LITERAL", "SIMPLE_NAME", "SOURCE_DIRECTIVE", 76 "SPARSE_SWITCH_DIRECTIVE", "STRING_LITERAL", "SUBANNOTATION_DIRECTIVE", 77 "SUPER_DIRECTIVE", "VERIFICATION_ERROR_TYPE", "VOID_TYPE", "VTABLE_INDEX", 78 "WHITE_SPACE" 79 }; 80 public static final int EOF=-1; 81 public static final int ACCESS_SPEC=4; 82 public static final int ANNOTATION_DIRECTIVE=5; 83 public static final int ANNOTATION_VISIBILITY=6; 84 public static final int ARRAY_DATA_DIRECTIVE=7; 85 public static final int ARRAY_DESCRIPTOR=8; 86 public static final int ARROW=9; 87 public static final int BOOL_LITERAL=10; 88 public static final int BYTE_LITERAL=11; 89 public static final int CATCHALL_DIRECTIVE=12; 90 public static final int CATCH_DIRECTIVE=13; 91 public static final int CHAR_LITERAL=14; 92 public static final int CLASS_DESCRIPTOR=15; 93 public static final int CLASS_DIRECTIVE=16; 94 public static final int CLOSE_BRACE=17; 95 public static final int CLOSE_PAREN=18; 96 public static final int COLON=19; 97 public static final int COMMA=20; 98 public static final int DOTDOT=21; 99 public static final int DOUBLE_LITERAL=22; 100 public static final int DOUBLE_LITERAL_OR_ID=23; 101 public static final int END_ANNOTATION_DIRECTIVE=24; 102 public static final int END_ARRAY_DATA_DIRECTIVE=25; 103 public static final int END_FIELD_DIRECTIVE=26; 104 public static final int END_LOCAL_DIRECTIVE=27; 105 public static final int END_METHOD_DIRECTIVE=28; 106 public static final int END_PACKED_SWITCH_DIRECTIVE=29; 107 public static final int END_PARAMETER_DIRECTIVE=30; 108 public static final int END_SPARSE_SWITCH_DIRECTIVE=31; 109 public static final int END_SUBANNOTATION_DIRECTIVE=32; 110 public static final int ENUM_DIRECTIVE=33; 111 public static final int EPILOGUE_DIRECTIVE=34; 112 public static final int EQUAL=35; 113 public static final int FIELD_DIRECTIVE=36; 114 public static final int FIELD_OFFSET=37; 115 public static final int FLOAT_LITERAL=38; 116 public static final int FLOAT_LITERAL_OR_ID=39; 117 public static final int IMPLEMENTS_DIRECTIVE=40; 118 public static final int INLINE_INDEX=41; 119 public static final int INSTRUCTION_FORMAT10t=42; 120 public static final int INSTRUCTION_FORMAT10x=43; 121 public static final int INSTRUCTION_FORMAT10x_ODEX=44; 122 public static final int INSTRUCTION_FORMAT11n=45; 123 public static final int INSTRUCTION_FORMAT11x=46; 124 public static final int INSTRUCTION_FORMAT12x=47; 125 public static final int INSTRUCTION_FORMAT12x_OR_ID=48; 126 public static final int INSTRUCTION_FORMAT20bc=49; 127 public static final int INSTRUCTION_FORMAT20t=50; 128 public static final int INSTRUCTION_FORMAT21c_FIELD=51; 129 public static final int INSTRUCTION_FORMAT21c_FIELD_ODEX=52; 130 public static final int INSTRUCTION_FORMAT21c_LAMBDA=53; 131 public static final int INSTRUCTION_FORMAT21c_METHOD=54; 132 public static final int INSTRUCTION_FORMAT21c_STRING=55; 133 public static final int INSTRUCTION_FORMAT21c_TYPE=56; 134 public static final int INSTRUCTION_FORMAT21ih=57; 135 public static final int INSTRUCTION_FORMAT21lh=58; 136 public static final int INSTRUCTION_FORMAT21s=59; 137 public static final int INSTRUCTION_FORMAT21t=60; 138 public static final int INSTRUCTION_FORMAT22b=61; 139 public static final int INSTRUCTION_FORMAT22c_FIELD=62; 140 public static final int INSTRUCTION_FORMAT22c_FIELD_ODEX=63; 141 public static final int INSTRUCTION_FORMAT22c_STRING=64; 142 public static final int INSTRUCTION_FORMAT22c_TYPE=65; 143 public static final int INSTRUCTION_FORMAT22cs_FIELD=66; 144 public static final int INSTRUCTION_FORMAT22s=67; 145 public static final int INSTRUCTION_FORMAT22s_OR_ID=68; 146 public static final int INSTRUCTION_FORMAT22t=69; 147 public static final int INSTRUCTION_FORMAT22x=70; 148 public static final int INSTRUCTION_FORMAT23x=71; 149 public static final int INSTRUCTION_FORMAT25x=72; 150 public static final int INSTRUCTION_FORMAT30t=73; 151 public static final int INSTRUCTION_FORMAT31c=74; 152 public static final int INSTRUCTION_FORMAT31i=75; 153 public static final int INSTRUCTION_FORMAT31i_OR_ID=76; 154 public static final int INSTRUCTION_FORMAT31t=77; 155 public static final int INSTRUCTION_FORMAT32x=78; 156 public static final int INSTRUCTION_FORMAT35c_METHOD=79; 157 public static final int INSTRUCTION_FORMAT35c_METHOD_ODEX=80; 158 public static final int INSTRUCTION_FORMAT35c_TYPE=81; 159 public static final int INSTRUCTION_FORMAT35mi_METHOD=82; 160 public static final int INSTRUCTION_FORMAT35ms_METHOD=83; 161 public static final int INSTRUCTION_FORMAT3rc_METHOD=84; 162 public static final int INSTRUCTION_FORMAT3rc_METHOD_ODEX=85; 163 public static final int INSTRUCTION_FORMAT3rc_TYPE=86; 164 public static final int INSTRUCTION_FORMAT3rmi_METHOD=87; 165 public static final int INSTRUCTION_FORMAT3rms_METHOD=88; 166 public static final int INSTRUCTION_FORMAT51l=89; 167 public static final int INTEGER_LITERAL=90; 168 public static final int INVALID_TOKEN=91; 169 public static final int I_ACCESS_LIST=92; 170 public static final int I_ANNOTATION=93; 171 public static final int I_ANNOTATIONS=94; 172 public static final int I_ANNOTATION_ELEMENT=95; 173 public static final int I_ARRAY_ELEMENTS=96; 174 public static final int I_ARRAY_ELEMENT_SIZE=97; 175 public static final int I_CATCH=98; 176 public static final int I_CATCHALL=99; 177 public static final int I_CATCHES=100; 178 public static final int I_CLASS_DEF=101; 179 public static final int I_ENCODED_ARRAY=102; 180 public static final int I_ENCODED_ENUM=103; 181 public static final int I_ENCODED_FIELD=104; 182 public static final int I_ENCODED_METHOD=105; 183 public static final int I_END_LOCAL=106; 184 public static final int I_EPILOGUE=107; 185 public static final int I_FIELD=108; 186 public static final int I_FIELDS=109; 187 public static final int I_FIELD_INITIAL_VALUE=110; 188 public static final int I_FIELD_TYPE=111; 189 public static final int I_IMPLEMENTS=112; 190 public static final int I_LABEL=113; 191 public static final int I_LINE=114; 192 public static final int I_LOCAL=115; 193 public static final int I_LOCALS=116; 194 public static final int I_METHOD=117; 195 public static final int I_METHODS=118; 196 public static final int I_METHOD_PROTOTYPE=119; 197 public static final int I_METHOD_RETURN_TYPE=120; 198 public static final int I_ORDERED_METHOD_ITEMS=121; 199 public static final int I_PACKED_SWITCH_ELEMENTS=122; 200 public static final int I_PACKED_SWITCH_START_KEY=123; 201 public static final int I_PARAMETER=124; 202 public static final int I_PARAMETERS=125; 203 public static final int I_PARAMETER_NOT_SPECIFIED=126; 204 public static final int I_PROLOGUE=127; 205 public static final int I_REGISTERS=128; 206 public static final int I_REGISTER_LIST=129; 207 public static final int I_REGISTER_RANGE=130; 208 public static final int I_RESTART_LOCAL=131; 209 public static final int I_SOURCE=132; 210 public static final int I_SPARSE_SWITCH_ELEMENTS=133; 211 public static final int I_STATEMENT_ARRAY_DATA=134; 212 public static final int I_STATEMENT_FORMAT10t=135; 213 public static final int I_STATEMENT_FORMAT10x=136; 214 public static final int I_STATEMENT_FORMAT11n=137; 215 public static final int I_STATEMENT_FORMAT11x=138; 216 public static final int I_STATEMENT_FORMAT12x=139; 217 public static final int I_STATEMENT_FORMAT20bc=140; 218 public static final int I_STATEMENT_FORMAT20t=141; 219 public static final int I_STATEMENT_FORMAT21c_FIELD=142; 220 public static final int I_STATEMENT_FORMAT21c_LAMBDA=143; 221 public static final int I_STATEMENT_FORMAT21c_METHOD=144; 222 public static final int I_STATEMENT_FORMAT21c_STRING=145; 223 public static final int I_STATEMENT_FORMAT21c_TYPE=146; 224 public static final int I_STATEMENT_FORMAT21ih=147; 225 public static final int I_STATEMENT_FORMAT21lh=148; 226 public static final int I_STATEMENT_FORMAT21s=149; 227 public static final int I_STATEMENT_FORMAT21t=150; 228 public static final int I_STATEMENT_FORMAT22b=151; 229 public static final int I_STATEMENT_FORMAT22c_FIELD=152; 230 public static final int I_STATEMENT_FORMAT22c_STRING=153; 231 public static final int I_STATEMENT_FORMAT22c_TYPE=154; 232 public static final int I_STATEMENT_FORMAT22s=155; 233 public static final int I_STATEMENT_FORMAT22t=156; 234 public static final int I_STATEMENT_FORMAT22x=157; 235 public static final int I_STATEMENT_FORMAT23x=158; 236 public static final int I_STATEMENT_FORMAT25x=159; 237 public static final int I_STATEMENT_FORMAT30t=160; 238 public static final int I_STATEMENT_FORMAT31c=161; 239 public static final int I_STATEMENT_FORMAT31i=162; 240 public static final int I_STATEMENT_FORMAT31t=163; 241 public static final int I_STATEMENT_FORMAT32x=164; 242 public static final int I_STATEMENT_FORMAT35c_METHOD=165; 243 public static final int I_STATEMENT_FORMAT35c_TYPE=166; 244 public static final int I_STATEMENT_FORMAT3rc_METHOD=167; 245 public static final int I_STATEMENT_FORMAT3rc_TYPE=168; 246 public static final int I_STATEMENT_FORMAT51l=169; 247 public static final int I_STATEMENT_PACKED_SWITCH=170; 248 public static final int I_STATEMENT_SPARSE_SWITCH=171; 249 public static final int I_SUBANNOTATION=172; 250 public static final int I_SUPER=173; 251 public static final int LINE_COMMENT=174; 252 public static final int LINE_DIRECTIVE=175; 253 public static final int LOCALS_DIRECTIVE=176; 254 public static final int LOCAL_DIRECTIVE=177; 255 public static final int LONG_LITERAL=178; 256 public static final int MEMBER_NAME=179; 257 public static final int METHOD_DIRECTIVE=180; 258 public static final int NEGATIVE_INTEGER_LITERAL=181; 259 public static final int NULL_LITERAL=182; 260 public static final int OPEN_BRACE=183; 261 public static final int OPEN_PAREN=184; 262 public static final int PACKED_SWITCH_DIRECTIVE=185; 263 public static final int PARAMETER_DIRECTIVE=186; 264 public static final int PARAM_LIST_END=187; 265 public static final int PARAM_LIST_OR_ID_END=188; 266 public static final int PARAM_LIST_OR_ID_START=189; 267 public static final int PARAM_LIST_START=190; 268 public static final int POSITIVE_INTEGER_LITERAL=191; 269 public static final int PRIMITIVE_TYPE=192; 270 public static final int PROLOGUE_DIRECTIVE=193; 271 public static final int REGISTER=194; 272 public static final int REGISTERS_DIRECTIVE=195; 273 public static final int RESTART_LOCAL_DIRECTIVE=196; 274 public static final int SHORT_LITERAL=197; 275 public static final int SIMPLE_NAME=198; 276 public static final int SOURCE_DIRECTIVE=199; 277 public static final int SPARSE_SWITCH_DIRECTIVE=200; 278 public static final int STRING_LITERAL=201; 279 public static final int SUBANNOTATION_DIRECTIVE=202; 280 public static final int SUPER_DIRECTIVE=203; 281 public static final int VERIFICATION_ERROR_TYPE=204; 282 public static final int VOID_TYPE=205; 283 public static final int VTABLE_INDEX=206; 284 public static final int WHITE_SPACE=207; 285 286 // delegates getDelegates()287 public Parser[] getDelegates() { 288 return new Parser[] {}; 289 } 290 291 // delegators 292 293 smaliParser(TokenStream input)294 public smaliParser(TokenStream input) { 295 this(input, new RecognizerSharedState()); 296 } smaliParser(TokenStream input, RecognizerSharedState state)297 public smaliParser(TokenStream input, RecognizerSharedState state) { 298 super(input, state); 299 } 300 301 protected TreeAdaptor adaptor = new CommonTreeAdaptor(); 302 setTreeAdaptor(TreeAdaptor adaptor)303 public void setTreeAdaptor(TreeAdaptor adaptor) { 304 this.adaptor = adaptor; 305 } getTreeAdaptor()306 public TreeAdaptor getTreeAdaptor() { 307 return adaptor; 308 } getTokenNames()309 @Override public String[] getTokenNames() { return smaliParser.tokenNames; } getGrammarFileName()310 @Override public String getGrammarFileName() { return "/mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g"; } 311 312 313 public static final int ERROR_CHANNEL = 100; 314 315 private boolean verboseErrors = false; 316 private boolean allowOdex = false; 317 private int apiLevel = 15; 318 private Opcodes opcodes = new Opcodes(apiLevel, false); 319 setVerboseErrors(boolean verboseErrors)320 public void setVerboseErrors(boolean verboseErrors) { 321 this.verboseErrors = verboseErrors; 322 } 323 setAllowOdex(boolean allowOdex)324 public void setAllowOdex(boolean allowOdex) { 325 this.allowOdex = allowOdex; 326 } 327 setApiLevel(int apiLevel, boolean experimental)328 public void setApiLevel(int apiLevel, boolean experimental) { 329 this.opcodes = new Opcodes(apiLevel, experimental); 330 this.apiLevel = apiLevel; 331 } 332 getErrorMessage(RecognitionException e, String[] tokenNames)333 public String getErrorMessage(RecognitionException e, 334 String[] tokenNames) { 335 336 if (verboseErrors) { 337 List stack = getRuleInvocationStack(e, this.getClass().getName()); 338 String msg = null; 339 340 if (e instanceof NoViableAltException) { 341 NoViableAltException nvae = (NoViableAltException)e; 342 msg = " no viable alt; token="+getTokenErrorDisplay(e.token)+ 343 " (decision="+nvae.decisionNumber+ 344 " state "+nvae.stateNumber+")"+ 345 " decision=<<"+nvae.grammarDecisionDescription+">>"; 346 } else { 347 msg = super.getErrorMessage(e, tokenNames); 348 } 349 350 return stack + " " + msg; 351 } else { 352 return super.getErrorMessage(e, tokenNames); 353 } 354 } 355 getTokenErrorDisplay(Token t)356 public String getTokenErrorDisplay(Token t) { 357 if (!verboseErrors) { 358 String s = t.getText(); 359 if ( s==null ) { 360 if ( t.getType()==Token.EOF ) { 361 s = "<EOF>"; 362 } 363 else { 364 s = "<"+tokenNames[t.getType()]+">"; 365 } 366 } 367 s = s.replaceAll("\n","\\\\n"); 368 s = s.replaceAll("\r","\\\\r"); 369 s = s.replaceAll("\t","\\\\t"); 370 return "'"+s+"'"; 371 } 372 373 CommonToken ct = (CommonToken)t; 374 375 String channelStr = ""; 376 if (t.getChannel()>0) { 377 channelStr=",channel="+t.getChannel(); 378 } 379 String txt = t.getText(); 380 if ( txt!=null ) { 381 txt = txt.replaceAll("\n","\\\\n"); 382 txt = txt.replaceAll("\r","\\\\r"); 383 txt = txt.replaceAll("\t","\\\\t"); 384 } 385 else { 386 txt = "<no text>"; 387 } 388 return "[@"+t.getTokenIndex()+","+ct.getStartIndex()+":"+ct.getStopIndex()+"='"+txt+"',<"+tokenNames[t.getType()]+">"+channelStr+","+t.getLine()+":"+t.getCharPositionInLine()+"]"; 389 } 390 getErrorHeader(RecognitionException e)391 public String getErrorHeader(RecognitionException e) { 392 return getSourceName()+"["+ e.line+","+e.charPositionInLine+"]"; 393 } 394 buildTree(int type, String text, List<CommonTree> children)395 private CommonTree buildTree(int type, String text, List<CommonTree> children) { 396 CommonTree root = new CommonTree(new CommonToken(type, text)); 397 for (CommonTree child: children) { 398 root.addChild(child); 399 } 400 return root; 401 } 402 getParamListSubToken(CommonToken baseToken, String str, int typeStartIndex)403 private CommonToken getParamListSubToken(CommonToken baseToken, String str, int typeStartIndex) { 404 CommonToken token = new CommonToken(baseToken); 405 token.setStartIndex(baseToken.getStartIndex() + typeStartIndex); 406 407 switch (str.charAt(typeStartIndex)) { 408 case 'Z': 409 case 'B': 410 case 'S': 411 case 'C': 412 case 'I': 413 case 'J': 414 case 'F': 415 case 'D': 416 { 417 token.setType(PRIMITIVE_TYPE); 418 token.setText(str.substring(typeStartIndex, typeStartIndex+1)); 419 token.setStopIndex(baseToken.getStartIndex() + typeStartIndex); 420 break; 421 } 422 case 'L': 423 { 424 int i = typeStartIndex; 425 while (str.charAt(++i) != ';'); 426 427 token.setType(CLASS_DESCRIPTOR); 428 token.setText(str.substring(typeStartIndex, i + 1)); 429 token.setStopIndex(baseToken.getStartIndex() + i); 430 break; 431 } 432 case '[': 433 { 434 int i = typeStartIndex; 435 while (str.charAt(++i) == '['); 436 437 if (str.charAt(i++) == 'L') { 438 while (str.charAt(i++) != ';'); 439 } 440 441 token.setType(ARRAY_DESCRIPTOR); 442 token.setText(str.substring(typeStartIndex, i)); 443 token.setStopIndex(baseToken.getStartIndex() + i - 1); 444 break; 445 } 446 default: 447 throw new RuntimeException(String.format("Invalid character '%c' in param list \"%s\" at position %d", str.charAt(typeStartIndex), str, typeStartIndex)); 448 } 449 450 return token; 451 } 452 parseParamList(CommonToken paramListToken)453 private CommonTree parseParamList(CommonToken paramListToken) { 454 String paramList = paramListToken.getText(); 455 CommonTree root = new CommonTree(); 456 457 int startIndex = paramListToken.getStartIndex(); 458 459 int i=0; 460 while (i<paramList.length()) { 461 CommonToken token = getParamListSubToken(paramListToken, paramList, i); 462 root.addChild(new CommonTree(token)); 463 i += token.getText().length(); 464 } 465 466 if (root.getChildCount() == 0) { 467 return null; 468 } 469 return root; 470 } 471 throwOdexedInstructionException(IntStream input, String odexedInstruction)472 private void throwOdexedInstructionException(IntStream input, String odexedInstruction) 473 throws OdexedInstructionException { 474 /*this has to be done in a separate method, otherwise java will complain about the 475 auto-generated code in the rule after the throw not being reachable*/ 476 throw new OdexedInstructionException(input, odexedInstruction); 477 } 478 479 480 protected static class smali_file_scope { 481 boolean hasClassSpec; 482 boolean hasSuperSpec; 483 boolean hasSourceSpec; 484 List<CommonTree> classAnnotations; 485 } 486 protected Stack<smali_file_scope> smali_file_stack = new Stack<smali_file_scope>(); 487 488 public static class smali_file_return extends ParserRuleReturnScope { 489 CommonTree tree; 490 @Override getTree()491 public CommonTree getTree() { return tree; } 492 }; 493 494 495 // $ANTLR start "smali_file" 496 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:426: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 )* ) ) ; smali_file()497 public final smaliParser.smali_file_return smali_file() throws RecognitionException { 498 smali_file_stack.push(new smali_file_scope()); 499 smaliParser.smali_file_return retval = new smaliParser.smali_file_return(); 500 retval.start = input.LT(1); 501 502 CommonTree root_0 = null; 503 504 Token EOF8=null; 505 ParserRuleReturnScope class_spec1 =null; 506 ParserRuleReturnScope super_spec2 =null; 507 ParserRuleReturnScope implements_spec3 =null; 508 ParserRuleReturnScope source_spec4 =null; 509 ParserRuleReturnScope method5 =null; 510 ParserRuleReturnScope field6 =null; 511 ParserRuleReturnScope annotation7 =null; 512 513 CommonTree EOF8_tree=null; 514 RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF"); 515 RewriteRuleSubtreeStream stream_field=new RewriteRuleSubtreeStream(adaptor,"rule field"); 516 RewriteRuleSubtreeStream stream_annotation=new RewriteRuleSubtreeStream(adaptor,"rule annotation"); 517 RewriteRuleSubtreeStream stream_super_spec=new RewriteRuleSubtreeStream(adaptor,"rule super_spec"); 518 RewriteRuleSubtreeStream stream_implements_spec=new RewriteRuleSubtreeStream(adaptor,"rule implements_spec"); 519 RewriteRuleSubtreeStream stream_source_spec=new RewriteRuleSubtreeStream(adaptor,"rule source_spec"); 520 RewriteRuleSubtreeStream stream_method=new RewriteRuleSubtreeStream(adaptor,"rule method"); 521 RewriteRuleSubtreeStream stream_class_spec=new RewriteRuleSubtreeStream(adaptor,"rule class_spec"); 522 523 smali_file_stack.peek().hasClassSpec = smali_file_stack.peek().hasSuperSpec = smali_file_stack.peek().hasSourceSpec = false; 524 smali_file_stack.peek().classAnnotations = new ArrayList<CommonTree>(); 525 526 try { 527 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:438: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 )* ) ) ) 528 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:439:3: ({...}? => class_spec |{...}? => super_spec | implements_spec |{...}? => source_spec | method | field | annotation )+ EOF 529 { 530 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:439:3: ({...}? => class_spec |{...}? => super_spec | implements_spec |{...}? => source_spec | method | field | annotation )+ 531 int cnt1=0; 532 loop1: 533 while (true) { 534 int alt1=8; 535 int LA1_0 = input.LA(1); 536 if ( (LA1_0==CLASS_DIRECTIVE) && ((!smali_file_stack.peek().hasClassSpec))) { 537 alt1=1; 538 } 539 else if ( (LA1_0==SUPER_DIRECTIVE) && ((!smali_file_stack.peek().hasSuperSpec))) { 540 alt1=2; 541 } 542 else if ( (LA1_0==IMPLEMENTS_DIRECTIVE) ) { 543 alt1=3; 544 } 545 else if ( (LA1_0==SOURCE_DIRECTIVE) && ((!smali_file_stack.peek().hasSourceSpec))) { 546 alt1=4; 547 } 548 else if ( (LA1_0==METHOD_DIRECTIVE) ) { 549 alt1=5; 550 } 551 else if ( (LA1_0==FIELD_DIRECTIVE) ) { 552 alt1=6; 553 } 554 else if ( (LA1_0==ANNOTATION_DIRECTIVE) ) { 555 alt1=7; 556 } 557 558 switch (alt1) { 559 case 1 : 560 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:439:5: {...}? => class_spec 561 { 562 if ( !((!smali_file_stack.peek().hasClassSpec)) ) { 563 throw new FailedPredicateException(input, "smali_file", "!$smali_file::hasClassSpec"); 564 } 565 pushFollow(FOLLOW_class_spec_in_smali_file1110); 566 class_spec1=class_spec(); 567 state._fsp--; 568 569 stream_class_spec.add(class_spec1.getTree()); 570 smali_file_stack.peek().hasClassSpec = true; 571 } 572 break; 573 case 2 : 574 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:440:5: {...}? => super_spec 575 { 576 if ( !((!smali_file_stack.peek().hasSuperSpec)) ) { 577 throw new FailedPredicateException(input, "smali_file", "!$smali_file::hasSuperSpec"); 578 } 579 pushFollow(FOLLOW_super_spec_in_smali_file1121); 580 super_spec2=super_spec(); 581 state._fsp--; 582 583 stream_super_spec.add(super_spec2.getTree()); 584 smali_file_stack.peek().hasSuperSpec = true; 585 } 586 break; 587 case 3 : 588 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:441:5: implements_spec 589 { 590 pushFollow(FOLLOW_implements_spec_in_smali_file1129); 591 implements_spec3=implements_spec(); 592 state._fsp--; 593 594 stream_implements_spec.add(implements_spec3.getTree()); 595 } 596 break; 597 case 4 : 598 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:442:5: {...}? => source_spec 599 { 600 if ( !((!smali_file_stack.peek().hasSourceSpec)) ) { 601 throw new FailedPredicateException(input, "smali_file", "!$smali_file::hasSourceSpec"); 602 } 603 pushFollow(FOLLOW_source_spec_in_smali_file1138); 604 source_spec4=source_spec(); 605 state._fsp--; 606 607 stream_source_spec.add(source_spec4.getTree()); 608 smali_file_stack.peek().hasSourceSpec = true; 609 } 610 break; 611 case 5 : 612 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:443:5: method 613 { 614 pushFollow(FOLLOW_method_in_smali_file1146); 615 method5=method(); 616 state._fsp--; 617 618 stream_method.add(method5.getTree()); 619 } 620 break; 621 case 6 : 622 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:444:5: field 623 { 624 pushFollow(FOLLOW_field_in_smali_file1152); 625 field6=field(); 626 state._fsp--; 627 628 stream_field.add(field6.getTree()); 629 } 630 break; 631 case 7 : 632 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:445:5: annotation 633 { 634 pushFollow(FOLLOW_annotation_in_smali_file1158); 635 annotation7=annotation(); 636 state._fsp--; 637 638 stream_annotation.add(annotation7.getTree()); 639 smali_file_stack.peek().classAnnotations.add((annotation7!=null?((CommonTree)annotation7.getTree()):null)); 640 } 641 break; 642 643 default : 644 if ( cnt1 >= 1 ) break loop1; 645 EarlyExitException eee = new EarlyExitException(1, input); 646 throw eee; 647 } 648 cnt1++; 649 } 650 651 EOF8=(Token)match(input,EOF,FOLLOW_EOF_in_smali_file1169); 652 stream_EOF.add(EOF8); 653 654 655 if (!smali_file_stack.peek().hasClassSpec) { 656 throw new SemanticException(input, "The file must contain a .class directive"); 657 } 658 659 if (!smali_file_stack.peek().hasSuperSpec) { 660 if (!(class_spec1!=null?((smaliParser.class_spec_return)class_spec1).className:null).equals("Ljava/lang/Object;")) { 661 throw new SemanticException(input, "The file must contain a .super directive"); 662 } 663 } 664 665 // AST REWRITE 666 // elements: field, source_spec, method, implements_spec, class_spec, super_spec 667 // token labels: 668 // rule labels: retval 669 // token list labels: 670 // rule list labels: 671 // wildcard labels: 672 retval.tree = root_0; 673 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 674 675 root_0 = (CommonTree)adaptor.nil(); 676 // 459:3: -> ^( I_CLASS_DEF class_spec ( super_spec )? ( implements_spec )* ( source_spec )? ^( I_METHODS ( method )* ) ^( I_FIELDS ( field )* ) ) 677 { 678 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:459:6: ^( I_CLASS_DEF class_spec ( super_spec )? ( implements_spec )* ( source_spec )? ^( I_METHODS ( method )* ) ^( I_FIELDS ( field )* ) ) 679 { 680 CommonTree root_1 = (CommonTree)adaptor.nil(); 681 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_CLASS_DEF, "I_CLASS_DEF"), root_1); 682 adaptor.addChild(root_1, stream_class_spec.nextTree()); 683 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:461:8: ( super_spec )? 684 if ( stream_super_spec.hasNext() ) { 685 adaptor.addChild(root_1, stream_super_spec.nextTree()); 686 } 687 stream_super_spec.reset(); 688 689 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:462:8: ( implements_spec )* 690 while ( stream_implements_spec.hasNext() ) { 691 adaptor.addChild(root_1, stream_implements_spec.nextTree()); 692 } 693 stream_implements_spec.reset(); 694 695 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:463:8: ( source_spec )? 696 if ( stream_source_spec.hasNext() ) { 697 adaptor.addChild(root_1, stream_source_spec.nextTree()); 698 } 699 stream_source_spec.reset(); 700 701 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:464:8: ^( I_METHODS ( method )* ) 702 { 703 CommonTree root_2 = (CommonTree)adaptor.nil(); 704 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_METHODS, "I_METHODS"), root_2); 705 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:464:20: ( method )* 706 while ( stream_method.hasNext() ) { 707 adaptor.addChild(root_2, stream_method.nextTree()); 708 } 709 stream_method.reset(); 710 711 adaptor.addChild(root_1, root_2); 712 } 713 714 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:464:29: ^( I_FIELDS ( field )* ) 715 { 716 CommonTree root_2 = (CommonTree)adaptor.nil(); 717 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELDS, "I_FIELDS"), root_2); 718 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:464:40: ( field )* 719 while ( stream_field.hasNext() ) { 720 adaptor.addChild(root_2, stream_field.nextTree()); 721 } 722 stream_field.reset(); 723 724 adaptor.addChild(root_1, root_2); 725 } 726 727 adaptor.addChild(root_1, buildTree(I_ANNOTATIONS, "I_ANNOTATIONS", smali_file_stack.peek().classAnnotations)); 728 adaptor.addChild(root_0, root_1); 729 } 730 731 } 732 733 734 retval.tree = root_0; 735 736 } 737 738 retval.stop = input.LT(-1); 739 740 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 741 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 742 743 } 744 catch (RecognitionException re) { 745 reportError(re); 746 recover(input,re); 747 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 748 } 749 finally { 750 // do for sure before leaving 751 smali_file_stack.pop(); 752 } 753 return retval; 754 } 755 // $ANTLR end "smali_file" 756 757 758 public static class class_spec_return extends ParserRuleReturnScope { 759 public String className; 760 CommonTree tree; 761 @Override getTree()762 public CommonTree getTree() { return tree; } 763 }; 764 765 766 // $ANTLR start "class_spec" 767 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:466:1: class_spec returns [String className] : CLASS_DIRECTIVE access_list CLASS_DESCRIPTOR -> CLASS_DESCRIPTOR access_list ; class_spec()768 public final smaliParser.class_spec_return class_spec() throws RecognitionException { 769 smaliParser.class_spec_return retval = new smaliParser.class_spec_return(); 770 retval.start = input.LT(1); 771 772 CommonTree root_0 = null; 773 774 Token CLASS_DIRECTIVE9=null; 775 Token CLASS_DESCRIPTOR11=null; 776 ParserRuleReturnScope access_list10 =null; 777 778 CommonTree CLASS_DIRECTIVE9_tree=null; 779 CommonTree CLASS_DESCRIPTOR11_tree=null; 780 RewriteRuleTokenStream stream_CLASS_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token CLASS_DIRECTIVE"); 781 RewriteRuleTokenStream stream_CLASS_DESCRIPTOR=new RewriteRuleTokenStream(adaptor,"token CLASS_DESCRIPTOR"); 782 RewriteRuleSubtreeStream stream_access_list=new RewriteRuleSubtreeStream(adaptor,"rule access_list"); 783 784 try { 785 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:467:3: ( CLASS_DIRECTIVE access_list CLASS_DESCRIPTOR -> CLASS_DESCRIPTOR access_list ) 786 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:467:5: CLASS_DIRECTIVE access_list CLASS_DESCRIPTOR 787 { 788 CLASS_DIRECTIVE9=(Token)match(input,CLASS_DIRECTIVE,FOLLOW_CLASS_DIRECTIVE_in_class_spec1256); 789 stream_CLASS_DIRECTIVE.add(CLASS_DIRECTIVE9); 790 791 pushFollow(FOLLOW_access_list_in_class_spec1258); 792 access_list10=access_list(); 793 state._fsp--; 794 795 stream_access_list.add(access_list10.getTree()); 796 CLASS_DESCRIPTOR11=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_class_spec1260); 797 stream_CLASS_DESCRIPTOR.add(CLASS_DESCRIPTOR11); 798 799 retval.className = (CLASS_DESCRIPTOR11!=null?CLASS_DESCRIPTOR11.getText():null); 800 // AST REWRITE 801 // elements: CLASS_DESCRIPTOR, access_list 802 // token labels: 803 // rule labels: retval 804 // token list labels: 805 // rule list labels: 806 // wildcard labels: 807 retval.tree = root_0; 808 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 809 810 root_0 = (CommonTree)adaptor.nil(); 811 // 467:89: -> CLASS_DESCRIPTOR access_list 812 { 813 adaptor.addChild(root_0, stream_CLASS_DESCRIPTOR.nextNode()); 814 adaptor.addChild(root_0, stream_access_list.nextTree()); 815 } 816 817 818 retval.tree = root_0; 819 820 } 821 822 retval.stop = input.LT(-1); 823 824 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 825 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 826 827 } 828 catch (RecognitionException re) { 829 reportError(re); 830 recover(input,re); 831 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 832 } 833 finally { 834 // do for sure before leaving 835 } 836 return retval; 837 } 838 // $ANTLR end "class_spec" 839 840 841 public static class super_spec_return extends ParserRuleReturnScope { 842 CommonTree tree; 843 @Override getTree()844 public CommonTree getTree() { return tree; } 845 }; 846 847 848 // $ANTLR start "super_spec" 849 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:469:1: super_spec : SUPER_DIRECTIVE CLASS_DESCRIPTOR -> ^( I_SUPER[$start, \"I_SUPER\"] CLASS_DESCRIPTOR ) ; super_spec()850 public final smaliParser.super_spec_return super_spec() throws RecognitionException { 851 smaliParser.super_spec_return retval = new smaliParser.super_spec_return(); 852 retval.start = input.LT(1); 853 854 CommonTree root_0 = null; 855 856 Token SUPER_DIRECTIVE12=null; 857 Token CLASS_DESCRIPTOR13=null; 858 859 CommonTree SUPER_DIRECTIVE12_tree=null; 860 CommonTree CLASS_DESCRIPTOR13_tree=null; 861 RewriteRuleTokenStream stream_SUPER_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token SUPER_DIRECTIVE"); 862 RewriteRuleTokenStream stream_CLASS_DESCRIPTOR=new RewriteRuleTokenStream(adaptor,"token CLASS_DESCRIPTOR"); 863 864 try { 865 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:470:3: ( SUPER_DIRECTIVE CLASS_DESCRIPTOR -> ^( I_SUPER[$start, \"I_SUPER\"] CLASS_DESCRIPTOR ) ) 866 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:470:5: SUPER_DIRECTIVE CLASS_DESCRIPTOR 867 { 868 SUPER_DIRECTIVE12=(Token)match(input,SUPER_DIRECTIVE,FOLLOW_SUPER_DIRECTIVE_in_super_spec1278); 869 stream_SUPER_DIRECTIVE.add(SUPER_DIRECTIVE12); 870 871 CLASS_DESCRIPTOR13=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_super_spec1280); 872 stream_CLASS_DESCRIPTOR.add(CLASS_DESCRIPTOR13); 873 874 // AST REWRITE 875 // elements: CLASS_DESCRIPTOR 876 // token labels: 877 // rule labels: retval 878 // token list labels: 879 // rule list labels: 880 // wildcard labels: 881 retval.tree = root_0; 882 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 883 884 root_0 = (CommonTree)adaptor.nil(); 885 // 470:38: -> ^( I_SUPER[$start, \"I_SUPER\"] CLASS_DESCRIPTOR ) 886 { 887 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:470:41: ^( I_SUPER[$start, \"I_SUPER\"] CLASS_DESCRIPTOR ) 888 { 889 CommonTree root_1 = (CommonTree)adaptor.nil(); 890 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SUPER, (retval.start), "I_SUPER"), root_1); 891 adaptor.addChild(root_1, stream_CLASS_DESCRIPTOR.nextNode()); 892 adaptor.addChild(root_0, root_1); 893 } 894 895 } 896 897 898 retval.tree = root_0; 899 900 } 901 902 retval.stop = input.LT(-1); 903 904 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 905 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 906 907 } 908 catch (RecognitionException re) { 909 reportError(re); 910 recover(input,re); 911 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 912 } 913 finally { 914 // do for sure before leaving 915 } 916 return retval; 917 } 918 // $ANTLR end "super_spec" 919 920 921 public static class implements_spec_return extends ParserRuleReturnScope { 922 CommonTree tree; 923 @Override getTree()924 public CommonTree getTree() { return tree; } 925 }; 926 927 928 // $ANTLR start "implements_spec" 929 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:472:1: implements_spec : IMPLEMENTS_DIRECTIVE CLASS_DESCRIPTOR -> ^( I_IMPLEMENTS[$start, \"I_IMPLEMENTS\"] CLASS_DESCRIPTOR ) ; implements_spec()930 public final smaliParser.implements_spec_return implements_spec() throws RecognitionException { 931 smaliParser.implements_spec_return retval = new smaliParser.implements_spec_return(); 932 retval.start = input.LT(1); 933 934 CommonTree root_0 = null; 935 936 Token IMPLEMENTS_DIRECTIVE14=null; 937 Token CLASS_DESCRIPTOR15=null; 938 939 CommonTree IMPLEMENTS_DIRECTIVE14_tree=null; 940 CommonTree CLASS_DESCRIPTOR15_tree=null; 941 RewriteRuleTokenStream stream_IMPLEMENTS_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token IMPLEMENTS_DIRECTIVE"); 942 RewriteRuleTokenStream stream_CLASS_DESCRIPTOR=new RewriteRuleTokenStream(adaptor,"token CLASS_DESCRIPTOR"); 943 944 try { 945 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:473:3: ( IMPLEMENTS_DIRECTIVE CLASS_DESCRIPTOR -> ^( I_IMPLEMENTS[$start, \"I_IMPLEMENTS\"] CLASS_DESCRIPTOR ) ) 946 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:473:5: IMPLEMENTS_DIRECTIVE CLASS_DESCRIPTOR 947 { 948 IMPLEMENTS_DIRECTIVE14=(Token)match(input,IMPLEMENTS_DIRECTIVE,FOLLOW_IMPLEMENTS_DIRECTIVE_in_implements_spec1299); 949 stream_IMPLEMENTS_DIRECTIVE.add(IMPLEMENTS_DIRECTIVE14); 950 951 CLASS_DESCRIPTOR15=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_implements_spec1301); 952 stream_CLASS_DESCRIPTOR.add(CLASS_DESCRIPTOR15); 953 954 // AST REWRITE 955 // elements: CLASS_DESCRIPTOR 956 // token labels: 957 // rule labels: retval 958 // token list labels: 959 // rule list labels: 960 // wildcard labels: 961 retval.tree = root_0; 962 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 963 964 root_0 = (CommonTree)adaptor.nil(); 965 // 473:43: -> ^( I_IMPLEMENTS[$start, \"I_IMPLEMENTS\"] CLASS_DESCRIPTOR ) 966 { 967 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:473:46: ^( I_IMPLEMENTS[$start, \"I_IMPLEMENTS\"] CLASS_DESCRIPTOR ) 968 { 969 CommonTree root_1 = (CommonTree)adaptor.nil(); 970 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_IMPLEMENTS, (retval.start), "I_IMPLEMENTS"), root_1); 971 adaptor.addChild(root_1, stream_CLASS_DESCRIPTOR.nextNode()); 972 adaptor.addChild(root_0, root_1); 973 } 974 975 } 976 977 978 retval.tree = root_0; 979 980 } 981 982 retval.stop = input.LT(-1); 983 984 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 985 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 986 987 } 988 catch (RecognitionException re) { 989 reportError(re); 990 recover(input,re); 991 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 992 } 993 finally { 994 // do for sure before leaving 995 } 996 return retval; 997 } 998 // $ANTLR end "implements_spec" 999 1000 1001 public static class source_spec_return extends ParserRuleReturnScope { 1002 CommonTree tree; 1003 @Override getTree()1004 public CommonTree getTree() { return tree; } 1005 }; 1006 1007 1008 // $ANTLR start "source_spec" 1009 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:475:1: source_spec : SOURCE_DIRECTIVE STRING_LITERAL -> ^( I_SOURCE[$start, \"I_SOURCE\"] STRING_LITERAL ) ; source_spec()1010 public final smaliParser.source_spec_return source_spec() throws RecognitionException { 1011 smaliParser.source_spec_return retval = new smaliParser.source_spec_return(); 1012 retval.start = input.LT(1); 1013 1014 CommonTree root_0 = null; 1015 1016 Token SOURCE_DIRECTIVE16=null; 1017 Token STRING_LITERAL17=null; 1018 1019 CommonTree SOURCE_DIRECTIVE16_tree=null; 1020 CommonTree STRING_LITERAL17_tree=null; 1021 RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL"); 1022 RewriteRuleTokenStream stream_SOURCE_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token SOURCE_DIRECTIVE"); 1023 1024 try { 1025 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:476:3: ( SOURCE_DIRECTIVE STRING_LITERAL -> ^( I_SOURCE[$start, \"I_SOURCE\"] STRING_LITERAL ) ) 1026 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:476:5: SOURCE_DIRECTIVE STRING_LITERAL 1027 { 1028 SOURCE_DIRECTIVE16=(Token)match(input,SOURCE_DIRECTIVE,FOLLOW_SOURCE_DIRECTIVE_in_source_spec1320); 1029 stream_SOURCE_DIRECTIVE.add(SOURCE_DIRECTIVE16); 1030 1031 STRING_LITERAL17=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_source_spec1322); 1032 stream_STRING_LITERAL.add(STRING_LITERAL17); 1033 1034 // AST REWRITE 1035 // elements: STRING_LITERAL 1036 // token labels: 1037 // rule labels: retval 1038 // token list labels: 1039 // rule list labels: 1040 // wildcard labels: 1041 retval.tree = root_0; 1042 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 1043 1044 root_0 = (CommonTree)adaptor.nil(); 1045 // 476:37: -> ^( I_SOURCE[$start, \"I_SOURCE\"] STRING_LITERAL ) 1046 { 1047 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:476:40: ^( I_SOURCE[$start, \"I_SOURCE\"] STRING_LITERAL ) 1048 { 1049 CommonTree root_1 = (CommonTree)adaptor.nil(); 1050 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SOURCE, (retval.start), "I_SOURCE"), root_1); 1051 adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode()); 1052 adaptor.addChild(root_0, root_1); 1053 } 1054 1055 } 1056 1057 1058 retval.tree = root_0; 1059 1060 } 1061 1062 retval.stop = input.LT(-1); 1063 1064 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 1065 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 1066 1067 } 1068 catch (RecognitionException re) { 1069 reportError(re); 1070 recover(input,re); 1071 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 1072 } 1073 finally { 1074 // do for sure before leaving 1075 } 1076 return retval; 1077 } 1078 // $ANTLR end "source_spec" 1079 1080 1081 public static class access_list_return extends ParserRuleReturnScope { 1082 CommonTree tree; 1083 @Override getTree()1084 public CommonTree getTree() { return tree; } 1085 }; 1086 1087 1088 // $ANTLR start "access_list" 1089 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:478:1: access_list : ( ACCESS_SPEC )* -> ^( I_ACCESS_LIST[$start,\"I_ACCESS_LIST\"] ( ACCESS_SPEC )* ) ; access_list()1090 public final smaliParser.access_list_return access_list() throws RecognitionException { 1091 smaliParser.access_list_return retval = new smaliParser.access_list_return(); 1092 retval.start = input.LT(1); 1093 1094 CommonTree root_0 = null; 1095 1096 Token ACCESS_SPEC18=null; 1097 1098 CommonTree ACCESS_SPEC18_tree=null; 1099 RewriteRuleTokenStream stream_ACCESS_SPEC=new RewriteRuleTokenStream(adaptor,"token ACCESS_SPEC"); 1100 1101 try { 1102 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:479:3: ( ( ACCESS_SPEC )* -> ^( I_ACCESS_LIST[$start,\"I_ACCESS_LIST\"] ( ACCESS_SPEC )* ) ) 1103 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:479:5: ( ACCESS_SPEC )* 1104 { 1105 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:479:5: ( ACCESS_SPEC )* 1106 loop2: 1107 while (true) { 1108 int alt2=2; 1109 int LA2_0 = input.LA(1); 1110 if ( (LA2_0==ACCESS_SPEC) ) { 1111 int LA2_2 = input.LA(2); 1112 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_FORMAT25x)||(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)) ) { 1113 alt2=1; 1114 } 1115 1116 } 1117 1118 switch (alt2) { 1119 case 1 : 1120 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:479:5: ACCESS_SPEC 1121 { 1122 ACCESS_SPEC18=(Token)match(input,ACCESS_SPEC,FOLLOW_ACCESS_SPEC_in_access_list1341); 1123 stream_ACCESS_SPEC.add(ACCESS_SPEC18); 1124 1125 } 1126 break; 1127 1128 default : 1129 break loop2; 1130 } 1131 } 1132 1133 // AST REWRITE 1134 // elements: ACCESS_SPEC 1135 // token labels: 1136 // rule labels: retval 1137 // token list labels: 1138 // rule list labels: 1139 // wildcard labels: 1140 retval.tree = root_0; 1141 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 1142 1143 root_0 = (CommonTree)adaptor.nil(); 1144 // 479:18: -> ^( I_ACCESS_LIST[$start,\"I_ACCESS_LIST\"] ( ACCESS_SPEC )* ) 1145 { 1146 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:479:21: ^( I_ACCESS_LIST[$start,\"I_ACCESS_LIST\"] ( ACCESS_SPEC )* ) 1147 { 1148 CommonTree root_1 = (CommonTree)adaptor.nil(); 1149 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ACCESS_LIST, (retval.start), "I_ACCESS_LIST"), root_1); 1150 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:479:61: ( ACCESS_SPEC )* 1151 while ( stream_ACCESS_SPEC.hasNext() ) { 1152 adaptor.addChild(root_1, stream_ACCESS_SPEC.nextNode()); 1153 } 1154 stream_ACCESS_SPEC.reset(); 1155 1156 adaptor.addChild(root_0, root_1); 1157 } 1158 1159 } 1160 1161 1162 retval.tree = root_0; 1163 1164 } 1165 1166 retval.stop = input.LT(-1); 1167 1168 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 1169 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 1170 1171 } 1172 catch (RecognitionException re) { 1173 reportError(re); 1174 recover(input,re); 1175 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 1176 } 1177 finally { 1178 // do for sure before leaving 1179 } 1180 return retval; 1181 } 1182 // $ANTLR end "access_list" 1183 1184 1185 public static class field_return extends ParserRuleReturnScope { 1186 CommonTree tree; 1187 @Override getTree()1188 public CommonTree getTree() { return tree; } 1189 }; 1190 1191 1192 // $ANTLR start "field" 1193 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:486: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 ) ) ) ) ; field()1194 public final smaliParser.field_return field() throws RecognitionException { 1195 smaliParser.field_return retval = new smaliParser.field_return(); 1196 retval.start = input.LT(1); 1197 1198 CommonTree root_0 = null; 1199 1200 Token FIELD_DIRECTIVE19=null; 1201 Token COLON22=null; 1202 Token EQUAL24=null; 1203 Token END_FIELD_DIRECTIVE27=null; 1204 ParserRuleReturnScope access_list20 =null; 1205 ParserRuleReturnScope member_name21 =null; 1206 ParserRuleReturnScope nonvoid_type_descriptor23 =null; 1207 ParserRuleReturnScope literal25 =null; 1208 ParserRuleReturnScope annotation26 =null; 1209 1210 CommonTree FIELD_DIRECTIVE19_tree=null; 1211 CommonTree COLON22_tree=null; 1212 CommonTree EQUAL24_tree=null; 1213 CommonTree END_FIELD_DIRECTIVE27_tree=null; 1214 RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON"); 1215 RewriteRuleTokenStream stream_FIELD_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token FIELD_DIRECTIVE"); 1216 RewriteRuleTokenStream stream_EQUAL=new RewriteRuleTokenStream(adaptor,"token EQUAL"); 1217 RewriteRuleTokenStream stream_END_FIELD_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_FIELD_DIRECTIVE"); 1218 RewriteRuleSubtreeStream stream_annotation=new RewriteRuleSubtreeStream(adaptor,"rule annotation"); 1219 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 1220 RewriteRuleSubtreeStream stream_access_list=new RewriteRuleSubtreeStream(adaptor,"rule access_list"); 1221 RewriteRuleSubtreeStream stream_member_name=new RewriteRuleSubtreeStream(adaptor,"rule member_name"); 1222 RewriteRuleSubtreeStream stream_literal=new RewriteRuleSubtreeStream(adaptor,"rule literal"); 1223 1224 List<CommonTree> annotations = new ArrayList<CommonTree>(); 1225 try { 1226 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:488: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 ) ) ) ) ) 1227 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:488: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 ) ) ) ) 1228 { 1229 FIELD_DIRECTIVE19=(Token)match(input,FIELD_DIRECTIVE,FOLLOW_FIELD_DIRECTIVE_in_field1372); 1230 stream_FIELD_DIRECTIVE.add(FIELD_DIRECTIVE19); 1231 1232 pushFollow(FOLLOW_access_list_in_field1374); 1233 access_list20=access_list(); 1234 state._fsp--; 1235 1236 stream_access_list.add(access_list20.getTree()); 1237 pushFollow(FOLLOW_member_name_in_field1376); 1238 member_name21=member_name(); 1239 state._fsp--; 1240 1241 stream_member_name.add(member_name21.getTree()); 1242 COLON22=(Token)match(input,COLON,FOLLOW_COLON_in_field1378); 1243 stream_COLON.add(COLON22); 1244 1245 pushFollow(FOLLOW_nonvoid_type_descriptor_in_field1380); 1246 nonvoid_type_descriptor23=nonvoid_type_descriptor(); 1247 state._fsp--; 1248 1249 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor23.getTree()); 1250 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:488:75: ( EQUAL literal )? 1251 int alt3=2; 1252 int LA3_0 = input.LA(1); 1253 if ( (LA3_0==EQUAL) ) { 1254 alt3=1; 1255 } 1256 switch (alt3) { 1257 case 1 : 1258 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:488:76: EQUAL literal 1259 { 1260 EQUAL24=(Token)match(input,EQUAL,FOLLOW_EQUAL_in_field1383); 1261 stream_EQUAL.add(EQUAL24); 1262 1263 pushFollow(FOLLOW_literal_in_field1385); 1264 literal25=literal(); 1265 state._fsp--; 1266 1267 stream_literal.add(literal25.getTree()); 1268 } 1269 break; 1270 1271 } 1272 1273 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:489: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 ) ) ) ) 1274 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:489: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 ) ) ) 1275 { 1276 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:489:7: ({...}? annotation )* 1277 loop4: 1278 while (true) { 1279 int alt4=2; 1280 int LA4_0 = input.LA(1); 1281 if ( (LA4_0==ANNOTATION_DIRECTIVE) ) { 1282 int LA4_9 = input.LA(2); 1283 if ( ((input.LA(1) == ANNOTATION_DIRECTIVE)) ) { 1284 alt4=1; 1285 } 1286 1287 } 1288 1289 switch (alt4) { 1290 case 1 : 1291 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:489:8: {...}? annotation 1292 { 1293 if ( !((input.LA(1) == ANNOTATION_DIRECTIVE)) ) { 1294 throw new FailedPredicateException(input, "field", "input.LA(1) == ANNOTATION_DIRECTIVE"); 1295 } 1296 pushFollow(FOLLOW_annotation_in_field1398); 1297 annotation26=annotation(); 1298 state._fsp--; 1299 1300 stream_annotation.add(annotation26.getTree()); 1301 annotations.add((annotation26!=null?((CommonTree)annotation26.getTree()):null)); 1302 } 1303 break; 1304 1305 default : 1306 break loop4; 1307 } 1308 } 1309 1310 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:490: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 ) ) ) 1311 int alt5=2; 1312 int LA5_0 = input.LA(1); 1313 if ( (LA5_0==END_FIELD_DIRECTIVE) ) { 1314 alt5=1; 1315 } 1316 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) ) { 1317 alt5=2; 1318 } 1319 1320 else { 1321 NoViableAltException nvae = 1322 new NoViableAltException("", 5, 0, input); 1323 throw nvae; 1324 } 1325 1326 switch (alt5) { 1327 case 1 : 1328 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:490:9: END_FIELD_DIRECTIVE 1329 { 1330 END_FIELD_DIRECTIVE27=(Token)match(input,END_FIELD_DIRECTIVE,FOLLOW_END_FIELD_DIRECTIVE_in_field1412); 1331 stream_END_FIELD_DIRECTIVE.add(END_FIELD_DIRECTIVE27); 1332 1333 // AST REWRITE 1334 // elements: nonvoid_type_descriptor, annotation, member_name, literal, access_list 1335 // token labels: 1336 // rule labels: retval 1337 // token list labels: 1338 // rule list labels: 1339 // wildcard labels: 1340 retval.tree = root_0; 1341 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 1342 1343 root_0 = (CommonTree)adaptor.nil(); 1344 // 491:9: -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ( annotation )* ) ) 1345 { 1346 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:491:12: ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ( annotation )* ) ) 1347 { 1348 CommonTree root_1 = (CommonTree)adaptor.nil(); 1349 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD, (retval.start), "I_FIELD"), root_1); 1350 adaptor.addChild(root_1, stream_member_name.nextTree()); 1351 adaptor.addChild(root_1, stream_access_list.nextTree()); 1352 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:491:65: ^( I_FIELD_TYPE nonvoid_type_descriptor ) 1353 { 1354 CommonTree root_2 = (CommonTree)adaptor.nil(); 1355 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD_TYPE, "I_FIELD_TYPE"), root_2); 1356 adaptor.addChild(root_2, stream_nonvoid_type_descriptor.nextTree()); 1357 adaptor.addChild(root_1, root_2); 1358 } 1359 1360 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:491:105: ( ^( I_FIELD_INITIAL_VALUE literal ) )? 1361 if ( stream_literal.hasNext() ) { 1362 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:491:105: ^( I_FIELD_INITIAL_VALUE literal ) 1363 { 1364 CommonTree root_2 = (CommonTree)adaptor.nil(); 1365 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD_INITIAL_VALUE, "I_FIELD_INITIAL_VALUE"), root_2); 1366 adaptor.addChild(root_2, stream_literal.nextTree()); 1367 adaptor.addChild(root_1, root_2); 1368 } 1369 1370 } 1371 stream_literal.reset(); 1372 1373 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:491:139: ^( I_ANNOTATIONS ( annotation )* ) 1374 { 1375 CommonTree root_2 = (CommonTree)adaptor.nil(); 1376 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATIONS, "I_ANNOTATIONS"), root_2); 1377 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:491:155: ( annotation )* 1378 while ( stream_annotation.hasNext() ) { 1379 adaptor.addChild(root_2, stream_annotation.nextTree()); 1380 } 1381 stream_annotation.reset(); 1382 1383 adaptor.addChild(root_1, root_2); 1384 } 1385 1386 adaptor.addChild(root_0, root_1); 1387 } 1388 1389 } 1390 1391 1392 retval.tree = root_0; 1393 1394 } 1395 break; 1396 case 2 : 1397 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:492:21: 1398 { 1399 smali_file_stack.peek().classAnnotations.addAll(annotations); 1400 // AST REWRITE 1401 // elements: access_list, nonvoid_type_descriptor, literal, member_name 1402 // token labels: 1403 // rule labels: retval 1404 // token list labels: 1405 // rule list labels: 1406 // wildcard labels: 1407 retval.tree = root_0; 1408 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 1409 1410 root_0 = (CommonTree)adaptor.nil(); 1411 // 493:9: -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ) ) 1412 { 1413 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:493:12: ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ) ) 1414 { 1415 CommonTree root_1 = (CommonTree)adaptor.nil(); 1416 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD, (retval.start), "I_FIELD"), root_1); 1417 adaptor.addChild(root_1, stream_member_name.nextTree()); 1418 adaptor.addChild(root_1, stream_access_list.nextTree()); 1419 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:493:65: ^( I_FIELD_TYPE nonvoid_type_descriptor ) 1420 { 1421 CommonTree root_2 = (CommonTree)adaptor.nil(); 1422 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD_TYPE, "I_FIELD_TYPE"), root_2); 1423 adaptor.addChild(root_2, stream_nonvoid_type_descriptor.nextTree()); 1424 adaptor.addChild(root_1, root_2); 1425 } 1426 1427 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:493:105: ( ^( I_FIELD_INITIAL_VALUE literal ) )? 1428 if ( stream_literal.hasNext() ) { 1429 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:493:105: ^( I_FIELD_INITIAL_VALUE literal ) 1430 { 1431 CommonTree root_2 = (CommonTree)adaptor.nil(); 1432 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD_INITIAL_VALUE, "I_FIELD_INITIAL_VALUE"), root_2); 1433 adaptor.addChild(root_2, stream_literal.nextTree()); 1434 adaptor.addChild(root_1, root_2); 1435 } 1436 1437 } 1438 stream_literal.reset(); 1439 1440 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:493:139: ^( I_ANNOTATIONS ) 1441 { 1442 CommonTree root_2 = (CommonTree)adaptor.nil(); 1443 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATIONS, "I_ANNOTATIONS"), root_2); 1444 adaptor.addChild(root_1, root_2); 1445 } 1446 1447 adaptor.addChild(root_0, root_1); 1448 } 1449 1450 } 1451 1452 1453 retval.tree = root_0; 1454 1455 } 1456 break; 1457 1458 } 1459 1460 } 1461 1462 } 1463 1464 retval.stop = input.LT(-1); 1465 1466 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 1467 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 1468 1469 } 1470 catch (RecognitionException re) { 1471 reportError(re); 1472 recover(input,re); 1473 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 1474 } 1475 finally { 1476 // do for sure before leaving 1477 } 1478 return retval; 1479 } 1480 // $ANTLR end "field" 1481 1482 1483 public static class method_return extends ParserRuleReturnScope { 1484 CommonTree tree; 1485 @Override getTree()1486 public CommonTree getTree() { return tree; } 1487 }; 1488 1489 1490 // $ANTLR start "method" 1491 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:497: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 ) ; method()1492 public final smaliParser.method_return method() throws RecognitionException { 1493 smaliParser.method_return retval = new smaliParser.method_return(); 1494 retval.start = input.LT(1); 1495 1496 CommonTree root_0 = null; 1497 1498 Token METHOD_DIRECTIVE28=null; 1499 Token END_METHOD_DIRECTIVE33=null; 1500 ParserRuleReturnScope access_list29 =null; 1501 ParserRuleReturnScope member_name30 =null; 1502 ParserRuleReturnScope method_prototype31 =null; 1503 ParserRuleReturnScope statements_and_directives32 =null; 1504 1505 CommonTree METHOD_DIRECTIVE28_tree=null; 1506 CommonTree END_METHOD_DIRECTIVE33_tree=null; 1507 RewriteRuleTokenStream stream_END_METHOD_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_METHOD_DIRECTIVE"); 1508 RewriteRuleTokenStream stream_METHOD_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token METHOD_DIRECTIVE"); 1509 RewriteRuleSubtreeStream stream_access_list=new RewriteRuleSubtreeStream(adaptor,"rule access_list"); 1510 RewriteRuleSubtreeStream stream_method_prototype=new RewriteRuleSubtreeStream(adaptor,"rule method_prototype"); 1511 RewriteRuleSubtreeStream stream_statements_and_directives=new RewriteRuleSubtreeStream(adaptor,"rule statements_and_directives"); 1512 RewriteRuleSubtreeStream stream_member_name=new RewriteRuleSubtreeStream(adaptor,"rule member_name"); 1513 1514 try { 1515 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:498: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 ) ) 1516 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:498:5: METHOD_DIRECTIVE access_list member_name method_prototype statements_and_directives END_METHOD_DIRECTIVE 1517 { 1518 METHOD_DIRECTIVE28=(Token)match(input,METHOD_DIRECTIVE,FOLLOW_METHOD_DIRECTIVE_in_method1523); 1519 stream_METHOD_DIRECTIVE.add(METHOD_DIRECTIVE28); 1520 1521 pushFollow(FOLLOW_access_list_in_method1525); 1522 access_list29=access_list(); 1523 state._fsp--; 1524 1525 stream_access_list.add(access_list29.getTree()); 1526 pushFollow(FOLLOW_member_name_in_method1527); 1527 member_name30=member_name(); 1528 state._fsp--; 1529 1530 stream_member_name.add(member_name30.getTree()); 1531 pushFollow(FOLLOW_method_prototype_in_method1529); 1532 method_prototype31=method_prototype(); 1533 state._fsp--; 1534 1535 stream_method_prototype.add(method_prototype31.getTree()); 1536 pushFollow(FOLLOW_statements_and_directives_in_method1531); 1537 statements_and_directives32=statements_and_directives(); 1538 state._fsp--; 1539 1540 stream_statements_and_directives.add(statements_and_directives32.getTree()); 1541 END_METHOD_DIRECTIVE33=(Token)match(input,END_METHOD_DIRECTIVE,FOLLOW_END_METHOD_DIRECTIVE_in_method1537); 1542 stream_END_METHOD_DIRECTIVE.add(END_METHOD_DIRECTIVE33); 1543 1544 // AST REWRITE 1545 // elements: access_list, method_prototype, statements_and_directives, member_name 1546 // token labels: 1547 // rule labels: retval 1548 // token list labels: 1549 // rule list labels: 1550 // wildcard labels: 1551 retval.tree = root_0; 1552 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 1553 1554 root_0 = (CommonTree)adaptor.nil(); 1555 // 500:5: -> ^( I_METHOD[$start, \"I_METHOD\"] member_name method_prototype access_list statements_and_directives ) 1556 { 1557 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:500:8: ^( I_METHOD[$start, \"I_METHOD\"] member_name method_prototype access_list statements_and_directives ) 1558 { 1559 CommonTree root_1 = (CommonTree)adaptor.nil(); 1560 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_METHOD, (retval.start), "I_METHOD"), root_1); 1561 adaptor.addChild(root_1, stream_member_name.nextTree()); 1562 adaptor.addChild(root_1, stream_method_prototype.nextTree()); 1563 adaptor.addChild(root_1, stream_access_list.nextTree()); 1564 adaptor.addChild(root_1, stream_statements_and_directives.nextTree()); 1565 adaptor.addChild(root_0, root_1); 1566 } 1567 1568 } 1569 1570 1571 retval.tree = root_0; 1572 1573 } 1574 1575 retval.stop = input.LT(-1); 1576 1577 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 1578 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 1579 1580 } 1581 catch (RecognitionException re) { 1582 reportError(re); 1583 recover(input,re); 1584 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 1585 } 1586 finally { 1587 // do for sure before leaving 1588 } 1589 return retval; 1590 } 1591 // $ANTLR end "method" 1592 1593 1594 protected static class statements_and_directives_scope { 1595 boolean hasRegistersDirective; 1596 List<CommonTree> methodAnnotations; 1597 } 1598 protected Stack<statements_and_directives_scope> statements_and_directives_stack = new Stack<statements_and_directives_scope>(); 1599 1600 public static class statements_and_directives_return extends ParserRuleReturnScope { 1601 CommonTree tree; 1602 @Override getTree()1603 public CommonTree getTree() { return tree; } 1604 }; 1605 1606 1607 // $ANTLR start "statements_and_directives" 1608 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:502: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 )* ) ; statements_and_directives()1609 public final smaliParser.statements_and_directives_return statements_and_directives() throws RecognitionException { 1610 statements_and_directives_stack.push(new statements_and_directives_scope()); 1611 smaliParser.statements_and_directives_return retval = new smaliParser.statements_and_directives_return(); 1612 retval.start = input.LT(1); 1613 1614 CommonTree root_0 = null; 1615 1616 ParserRuleReturnScope ordered_method_item34 =null; 1617 ParserRuleReturnScope registers_directive35 =null; 1618 ParserRuleReturnScope catch_directive36 =null; 1619 ParserRuleReturnScope catchall_directive37 =null; 1620 ParserRuleReturnScope parameter_directive38 =null; 1621 ParserRuleReturnScope annotation39 =null; 1622 1623 RewriteRuleSubtreeStream stream_catchall_directive=new RewriteRuleSubtreeStream(adaptor,"rule catchall_directive"); 1624 RewriteRuleSubtreeStream stream_annotation=new RewriteRuleSubtreeStream(adaptor,"rule annotation"); 1625 RewriteRuleSubtreeStream stream_ordered_method_item=new RewriteRuleSubtreeStream(adaptor,"rule ordered_method_item"); 1626 RewriteRuleSubtreeStream stream_catch_directive=new RewriteRuleSubtreeStream(adaptor,"rule catch_directive"); 1627 RewriteRuleSubtreeStream stream_registers_directive=new RewriteRuleSubtreeStream(adaptor,"rule registers_directive"); 1628 RewriteRuleSubtreeStream stream_parameter_directive=new RewriteRuleSubtreeStream(adaptor,"rule parameter_directive"); 1629 1630 try { 1631 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:508: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 )* ) ) 1632 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:508:5: ( ordered_method_item | registers_directive | catch_directive | catchall_directive | parameter_directive | annotation )* 1633 { 1634 1635 statements_and_directives_stack.peek().hasRegistersDirective = false; 1636 statements_and_directives_stack.peek().methodAnnotations = new ArrayList<CommonTree>(); 1637 1638 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:512:5: ( ordered_method_item | registers_directive | catch_directive | catchall_directive | parameter_directive | annotation )* 1639 loop6: 1640 while (true) { 1641 int alt6=7; 1642 switch ( input.LA(1) ) { 1643 case ARRAY_DATA_DIRECTIVE: 1644 case COLON: 1645 case END_LOCAL_DIRECTIVE: 1646 case EPILOGUE_DIRECTIVE: 1647 case INSTRUCTION_FORMAT10t: 1648 case INSTRUCTION_FORMAT10x: 1649 case INSTRUCTION_FORMAT10x_ODEX: 1650 case INSTRUCTION_FORMAT11n: 1651 case INSTRUCTION_FORMAT11x: 1652 case INSTRUCTION_FORMAT12x: 1653 case INSTRUCTION_FORMAT12x_OR_ID: 1654 case INSTRUCTION_FORMAT20bc: 1655 case INSTRUCTION_FORMAT20t: 1656 case INSTRUCTION_FORMAT21c_FIELD: 1657 case INSTRUCTION_FORMAT21c_FIELD_ODEX: 1658 case INSTRUCTION_FORMAT21c_LAMBDA: 1659 case INSTRUCTION_FORMAT21c_METHOD: 1660 case INSTRUCTION_FORMAT21c_STRING: 1661 case INSTRUCTION_FORMAT21c_TYPE: 1662 case INSTRUCTION_FORMAT21ih: 1663 case INSTRUCTION_FORMAT21lh: 1664 case INSTRUCTION_FORMAT21s: 1665 case INSTRUCTION_FORMAT21t: 1666 case INSTRUCTION_FORMAT22b: 1667 case INSTRUCTION_FORMAT22c_FIELD: 1668 case INSTRUCTION_FORMAT22c_FIELD_ODEX: 1669 case INSTRUCTION_FORMAT22c_STRING: 1670 case INSTRUCTION_FORMAT22c_TYPE: 1671 case INSTRUCTION_FORMAT22cs_FIELD: 1672 case INSTRUCTION_FORMAT22s: 1673 case INSTRUCTION_FORMAT22s_OR_ID: 1674 case INSTRUCTION_FORMAT22t: 1675 case INSTRUCTION_FORMAT22x: 1676 case INSTRUCTION_FORMAT23x: 1677 case INSTRUCTION_FORMAT25x: 1678 case INSTRUCTION_FORMAT30t: 1679 case INSTRUCTION_FORMAT31c: 1680 case INSTRUCTION_FORMAT31i: 1681 case INSTRUCTION_FORMAT31i_OR_ID: 1682 case INSTRUCTION_FORMAT31t: 1683 case INSTRUCTION_FORMAT32x: 1684 case INSTRUCTION_FORMAT35c_METHOD: 1685 case INSTRUCTION_FORMAT35c_METHOD_ODEX: 1686 case INSTRUCTION_FORMAT35c_TYPE: 1687 case INSTRUCTION_FORMAT35mi_METHOD: 1688 case INSTRUCTION_FORMAT35ms_METHOD: 1689 case INSTRUCTION_FORMAT3rc_METHOD: 1690 case INSTRUCTION_FORMAT3rc_METHOD_ODEX: 1691 case INSTRUCTION_FORMAT3rc_TYPE: 1692 case INSTRUCTION_FORMAT3rmi_METHOD: 1693 case INSTRUCTION_FORMAT3rms_METHOD: 1694 case INSTRUCTION_FORMAT51l: 1695 case LINE_DIRECTIVE: 1696 case LOCAL_DIRECTIVE: 1697 case PACKED_SWITCH_DIRECTIVE: 1698 case PROLOGUE_DIRECTIVE: 1699 case RESTART_LOCAL_DIRECTIVE: 1700 case SOURCE_DIRECTIVE: 1701 case SPARSE_SWITCH_DIRECTIVE: 1702 { 1703 alt6=1; 1704 } 1705 break; 1706 case LOCALS_DIRECTIVE: 1707 case REGISTERS_DIRECTIVE: 1708 { 1709 alt6=2; 1710 } 1711 break; 1712 case CATCH_DIRECTIVE: 1713 { 1714 alt6=3; 1715 } 1716 break; 1717 case CATCHALL_DIRECTIVE: 1718 { 1719 alt6=4; 1720 } 1721 break; 1722 case PARAMETER_DIRECTIVE: 1723 { 1724 alt6=5; 1725 } 1726 break; 1727 case ANNOTATION_DIRECTIVE: 1728 { 1729 alt6=6; 1730 } 1731 break; 1732 } 1733 switch (alt6) { 1734 case 1 : 1735 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:512:7: ordered_method_item 1736 { 1737 pushFollow(FOLLOW_ordered_method_item_in_statements_and_directives1582); 1738 ordered_method_item34=ordered_method_item(); 1739 state._fsp--; 1740 1741 stream_ordered_method_item.add(ordered_method_item34.getTree()); 1742 } 1743 break; 1744 case 2 : 1745 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:513:7: registers_directive 1746 { 1747 pushFollow(FOLLOW_registers_directive_in_statements_and_directives1590); 1748 registers_directive35=registers_directive(); 1749 state._fsp--; 1750 1751 stream_registers_directive.add(registers_directive35.getTree()); 1752 } 1753 break; 1754 case 3 : 1755 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:514:7: catch_directive 1756 { 1757 pushFollow(FOLLOW_catch_directive_in_statements_and_directives1598); 1758 catch_directive36=catch_directive(); 1759 state._fsp--; 1760 1761 stream_catch_directive.add(catch_directive36.getTree()); 1762 } 1763 break; 1764 case 4 : 1765 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:515:7: catchall_directive 1766 { 1767 pushFollow(FOLLOW_catchall_directive_in_statements_and_directives1606); 1768 catchall_directive37=catchall_directive(); 1769 state._fsp--; 1770 1771 stream_catchall_directive.add(catchall_directive37.getTree()); 1772 } 1773 break; 1774 case 5 : 1775 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:516:7: parameter_directive 1776 { 1777 pushFollow(FOLLOW_parameter_directive_in_statements_and_directives1614); 1778 parameter_directive38=parameter_directive(); 1779 state._fsp--; 1780 1781 stream_parameter_directive.add(parameter_directive38.getTree()); 1782 } 1783 break; 1784 case 6 : 1785 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:517:7: annotation 1786 { 1787 pushFollow(FOLLOW_annotation_in_statements_and_directives1622); 1788 annotation39=annotation(); 1789 state._fsp--; 1790 1791 stream_annotation.add(annotation39.getTree()); 1792 statements_and_directives_stack.peek().methodAnnotations.add((annotation39!=null?((CommonTree)annotation39.getTree()):null)); 1793 } 1794 break; 1795 1796 default : 1797 break loop6; 1798 } 1799 } 1800 1801 // AST REWRITE 1802 // elements: parameter_directive, catch_directive, catchall_directive, ordered_method_item, registers_directive 1803 // token labels: 1804 // rule labels: retval 1805 // token list labels: 1806 // rule list labels: 1807 // wildcard labels: 1808 retval.tree = root_0; 1809 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 1810 1811 root_0 = (CommonTree)adaptor.nil(); 1812 // 519:5: -> ( registers_directive )? ^( I_ORDERED_METHOD_ITEMS ( ordered_method_item )* ) ^( I_CATCHES ( catch_directive )* ( catchall_directive )* ) ^( I_PARAMETERS ( parameter_directive )* ) 1813 { 1814 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:519:8: ( registers_directive )? 1815 if ( stream_registers_directive.hasNext() ) { 1816 adaptor.addChild(root_0, stream_registers_directive.nextTree()); 1817 } 1818 stream_registers_directive.reset(); 1819 1820 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:520:8: ^( I_ORDERED_METHOD_ITEMS ( ordered_method_item )* ) 1821 { 1822 CommonTree root_1 = (CommonTree)adaptor.nil(); 1823 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ORDERED_METHOD_ITEMS, "I_ORDERED_METHOD_ITEMS"), root_1); 1824 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:520:33: ( ordered_method_item )* 1825 while ( stream_ordered_method_item.hasNext() ) { 1826 adaptor.addChild(root_1, stream_ordered_method_item.nextTree()); 1827 } 1828 stream_ordered_method_item.reset(); 1829 1830 adaptor.addChild(root_0, root_1); 1831 } 1832 1833 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:521:8: ^( I_CATCHES ( catch_directive )* ( catchall_directive )* ) 1834 { 1835 CommonTree root_1 = (CommonTree)adaptor.nil(); 1836 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_CATCHES, "I_CATCHES"), root_1); 1837 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:521:20: ( catch_directive )* 1838 while ( stream_catch_directive.hasNext() ) { 1839 adaptor.addChild(root_1, stream_catch_directive.nextTree()); 1840 } 1841 stream_catch_directive.reset(); 1842 1843 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:521:37: ( catchall_directive )* 1844 while ( stream_catchall_directive.hasNext() ) { 1845 adaptor.addChild(root_1, stream_catchall_directive.nextTree()); 1846 } 1847 stream_catchall_directive.reset(); 1848 1849 adaptor.addChild(root_0, root_1); 1850 } 1851 1852 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:522:8: ^( I_PARAMETERS ( parameter_directive )* ) 1853 { 1854 CommonTree root_1 = (CommonTree)adaptor.nil(); 1855 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_PARAMETERS, "I_PARAMETERS"), root_1); 1856 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:522:23: ( parameter_directive )* 1857 while ( stream_parameter_directive.hasNext() ) { 1858 adaptor.addChild(root_1, stream_parameter_directive.nextTree()); 1859 } 1860 stream_parameter_directive.reset(); 1861 1862 adaptor.addChild(root_0, root_1); 1863 } 1864 1865 adaptor.addChild(root_0, buildTree(I_ANNOTATIONS, "I_ANNOTATIONS", statements_and_directives_stack.peek().methodAnnotations)); 1866 } 1867 1868 1869 retval.tree = root_0; 1870 1871 } 1872 1873 retval.stop = input.LT(-1); 1874 1875 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 1876 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 1877 1878 } 1879 catch (RecognitionException re) { 1880 reportError(re); 1881 recover(input,re); 1882 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 1883 } 1884 finally { 1885 // do for sure before leaving 1886 statements_and_directives_stack.pop(); 1887 } 1888 return retval; 1889 } 1890 // $ANTLR end "statements_and_directives" 1891 1892 1893 public static class ordered_method_item_return extends ParserRuleReturnScope { 1894 CommonTree tree; 1895 @Override getTree()1896 public CommonTree getTree() { return tree; } 1897 }; 1898 1899 1900 // $ANTLR start "ordered_method_item" 1901 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:526:1: ordered_method_item : ( label | instruction | debug_directive ); ordered_method_item()1902 public final smaliParser.ordered_method_item_return ordered_method_item() throws RecognitionException { 1903 smaliParser.ordered_method_item_return retval = new smaliParser.ordered_method_item_return(); 1904 retval.start = input.LT(1); 1905 1906 CommonTree root_0 = null; 1907 1908 ParserRuleReturnScope label40 =null; 1909 ParserRuleReturnScope instruction41 =null; 1910 ParserRuleReturnScope debug_directive42 =null; 1911 1912 1913 try { 1914 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:527:3: ( label | instruction | debug_directive ) 1915 int alt7=3; 1916 switch ( input.LA(1) ) { 1917 case COLON: 1918 { 1919 alt7=1; 1920 } 1921 break; 1922 case ARRAY_DATA_DIRECTIVE: 1923 case INSTRUCTION_FORMAT10t: 1924 case INSTRUCTION_FORMAT10x: 1925 case INSTRUCTION_FORMAT10x_ODEX: 1926 case INSTRUCTION_FORMAT11n: 1927 case INSTRUCTION_FORMAT11x: 1928 case INSTRUCTION_FORMAT12x: 1929 case INSTRUCTION_FORMAT12x_OR_ID: 1930 case INSTRUCTION_FORMAT20bc: 1931 case INSTRUCTION_FORMAT20t: 1932 case INSTRUCTION_FORMAT21c_FIELD: 1933 case INSTRUCTION_FORMAT21c_FIELD_ODEX: 1934 case INSTRUCTION_FORMAT21c_LAMBDA: 1935 case INSTRUCTION_FORMAT21c_METHOD: 1936 case INSTRUCTION_FORMAT21c_STRING: 1937 case INSTRUCTION_FORMAT21c_TYPE: 1938 case INSTRUCTION_FORMAT21ih: 1939 case INSTRUCTION_FORMAT21lh: 1940 case INSTRUCTION_FORMAT21s: 1941 case INSTRUCTION_FORMAT21t: 1942 case INSTRUCTION_FORMAT22b: 1943 case INSTRUCTION_FORMAT22c_FIELD: 1944 case INSTRUCTION_FORMAT22c_FIELD_ODEX: 1945 case INSTRUCTION_FORMAT22c_STRING: 1946 case INSTRUCTION_FORMAT22c_TYPE: 1947 case INSTRUCTION_FORMAT22cs_FIELD: 1948 case INSTRUCTION_FORMAT22s: 1949 case INSTRUCTION_FORMAT22s_OR_ID: 1950 case INSTRUCTION_FORMAT22t: 1951 case INSTRUCTION_FORMAT22x: 1952 case INSTRUCTION_FORMAT23x: 1953 case INSTRUCTION_FORMAT25x: 1954 case INSTRUCTION_FORMAT30t: 1955 case INSTRUCTION_FORMAT31c: 1956 case INSTRUCTION_FORMAT31i: 1957 case INSTRUCTION_FORMAT31i_OR_ID: 1958 case INSTRUCTION_FORMAT31t: 1959 case INSTRUCTION_FORMAT32x: 1960 case INSTRUCTION_FORMAT35c_METHOD: 1961 case INSTRUCTION_FORMAT35c_METHOD_ODEX: 1962 case INSTRUCTION_FORMAT35c_TYPE: 1963 case INSTRUCTION_FORMAT35mi_METHOD: 1964 case INSTRUCTION_FORMAT35ms_METHOD: 1965 case INSTRUCTION_FORMAT3rc_METHOD: 1966 case INSTRUCTION_FORMAT3rc_METHOD_ODEX: 1967 case INSTRUCTION_FORMAT3rc_TYPE: 1968 case INSTRUCTION_FORMAT3rmi_METHOD: 1969 case INSTRUCTION_FORMAT3rms_METHOD: 1970 case INSTRUCTION_FORMAT51l: 1971 case PACKED_SWITCH_DIRECTIVE: 1972 case SPARSE_SWITCH_DIRECTIVE: 1973 { 1974 alt7=2; 1975 } 1976 break; 1977 case END_LOCAL_DIRECTIVE: 1978 case EPILOGUE_DIRECTIVE: 1979 case LINE_DIRECTIVE: 1980 case LOCAL_DIRECTIVE: 1981 case PROLOGUE_DIRECTIVE: 1982 case RESTART_LOCAL_DIRECTIVE: 1983 case SOURCE_DIRECTIVE: 1984 { 1985 alt7=3; 1986 } 1987 break; 1988 default: 1989 NoViableAltException nvae = 1990 new NoViableAltException("", 7, 0, input); 1991 throw nvae; 1992 } 1993 switch (alt7) { 1994 case 1 : 1995 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:527:5: label 1996 { 1997 root_0 = (CommonTree)adaptor.nil(); 1998 1999 2000 pushFollow(FOLLOW_label_in_ordered_method_item1707); 2001 label40=label(); 2002 state._fsp--; 2003 2004 adaptor.addChild(root_0, label40.getTree()); 2005 2006 } 2007 break; 2008 case 2 : 2009 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:528:5: instruction 2010 { 2011 root_0 = (CommonTree)adaptor.nil(); 2012 2013 2014 pushFollow(FOLLOW_instruction_in_ordered_method_item1713); 2015 instruction41=instruction(); 2016 state._fsp--; 2017 2018 adaptor.addChild(root_0, instruction41.getTree()); 2019 2020 } 2021 break; 2022 case 3 : 2023 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:529:5: debug_directive 2024 { 2025 root_0 = (CommonTree)adaptor.nil(); 2026 2027 2028 pushFollow(FOLLOW_debug_directive_in_ordered_method_item1719); 2029 debug_directive42=debug_directive(); 2030 state._fsp--; 2031 2032 adaptor.addChild(root_0, debug_directive42.getTree()); 2033 2034 } 2035 break; 2036 2037 } 2038 retval.stop = input.LT(-1); 2039 2040 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 2041 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 2042 2043 } 2044 catch (RecognitionException re) { 2045 reportError(re); 2046 recover(input,re); 2047 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 2048 } 2049 finally { 2050 // do for sure before leaving 2051 } 2052 return retval; 2053 } 2054 // $ANTLR end "ordered_method_item" 2055 2056 2057 public static class registers_directive_return extends ParserRuleReturnScope { 2058 CommonTree tree; 2059 @Override getTree()2060 public CommonTree getTree() { return tree; } 2061 }; 2062 2063 2064 // $ANTLR start "registers_directive" 2065 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:531: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) ) ; registers_directive()2066 public final smaliParser.registers_directive_return registers_directive() throws RecognitionException { 2067 smaliParser.registers_directive_return retval = new smaliParser.registers_directive_return(); 2068 retval.start = input.LT(1); 2069 2070 CommonTree root_0 = null; 2071 2072 Token directive=null; 2073 ParserRuleReturnScope regCount =null; 2074 ParserRuleReturnScope regCount2 =null; 2075 2076 CommonTree directive_tree=null; 2077 RewriteRuleTokenStream stream_REGISTERS_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token REGISTERS_DIRECTIVE"); 2078 RewriteRuleTokenStream stream_LOCALS_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token LOCALS_DIRECTIVE"); 2079 RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal"); 2080 2081 try { 2082 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:532: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) ) ) 2083 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:532: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) ) 2084 { 2085 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:532: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) ) 2086 int alt8=2; 2087 int LA8_0 = input.LA(1); 2088 if ( (LA8_0==REGISTERS_DIRECTIVE) ) { 2089 alt8=1; 2090 } 2091 else if ( (LA8_0==LOCALS_DIRECTIVE) ) { 2092 alt8=2; 2093 } 2094 2095 else { 2096 NoViableAltException nvae = 2097 new NoViableAltException("", 8, 0, input); 2098 throw nvae; 2099 } 2100 2101 switch (alt8) { 2102 case 1 : 2103 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:533:7: directive= REGISTERS_DIRECTIVE regCount= integral_literal 2104 { 2105 directive=(Token)match(input,REGISTERS_DIRECTIVE,FOLLOW_REGISTERS_DIRECTIVE_in_registers_directive1739); 2106 stream_REGISTERS_DIRECTIVE.add(directive); 2107 2108 pushFollow(FOLLOW_integral_literal_in_registers_directive1743); 2109 regCount=integral_literal(); 2110 state._fsp--; 2111 2112 stream_integral_literal.add(regCount.getTree()); 2113 // AST REWRITE 2114 // elements: regCount 2115 // token labels: 2116 // rule labels: retval, regCount 2117 // token list labels: 2118 // rule list labels: 2119 // wildcard labels: 2120 retval.tree = root_0; 2121 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2122 RewriteRuleSubtreeStream stream_regCount=new RewriteRuleSubtreeStream(adaptor,"rule regCount",regCount!=null?regCount.getTree():null); 2123 2124 root_0 = (CommonTree)adaptor.nil(); 2125 // 533:63: -> ^( I_REGISTERS[$REGISTERS_DIRECTIVE, \"I_REGISTERS\"] $regCount) 2126 { 2127 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:533:66: ^( I_REGISTERS[$REGISTERS_DIRECTIVE, \"I_REGISTERS\"] $regCount) 2128 { 2129 CommonTree root_1 = (CommonTree)adaptor.nil(); 2130 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_REGISTERS, directive, "I_REGISTERS"), root_1); 2131 adaptor.addChild(root_1, stream_regCount.nextTree()); 2132 adaptor.addChild(root_0, root_1); 2133 } 2134 2135 } 2136 2137 2138 retval.tree = root_0; 2139 2140 } 2141 break; 2142 case 2 : 2143 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:534:7: directive= LOCALS_DIRECTIVE regCount2= integral_literal 2144 { 2145 directive=(Token)match(input,LOCALS_DIRECTIVE,FOLLOW_LOCALS_DIRECTIVE_in_registers_directive1763); 2146 stream_LOCALS_DIRECTIVE.add(directive); 2147 2148 pushFollow(FOLLOW_integral_literal_in_registers_directive1767); 2149 regCount2=integral_literal(); 2150 state._fsp--; 2151 2152 stream_integral_literal.add(regCount2.getTree()); 2153 // AST REWRITE 2154 // elements: regCount2 2155 // token labels: 2156 // rule labels: retval, regCount2 2157 // token list labels: 2158 // rule list labels: 2159 // wildcard labels: 2160 retval.tree = root_0; 2161 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2162 RewriteRuleSubtreeStream stream_regCount2=new RewriteRuleSubtreeStream(adaptor,"rule regCount2",regCount2!=null?regCount2.getTree():null); 2163 2164 root_0 = (CommonTree)adaptor.nil(); 2165 // 534:61: -> ^( I_LOCALS[$LOCALS_DIRECTIVE, \"I_LOCALS\"] $regCount2) 2166 { 2167 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:534:64: ^( I_LOCALS[$LOCALS_DIRECTIVE, \"I_LOCALS\"] $regCount2) 2168 { 2169 CommonTree root_1 = (CommonTree)adaptor.nil(); 2170 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_LOCALS, directive, "I_LOCALS"), root_1); 2171 adaptor.addChild(root_1, stream_regCount2.nextTree()); 2172 adaptor.addChild(root_0, root_1); 2173 } 2174 2175 } 2176 2177 2178 retval.tree = root_0; 2179 2180 } 2181 break; 2182 2183 } 2184 2185 2186 if (statements_and_directives_stack.peek().hasRegistersDirective) { 2187 throw new SemanticException(input, directive, "There can only be a single .registers or .locals directive in a method"); 2188 } 2189 statements_and_directives_stack.peek().hasRegistersDirective =true; 2190 2191 } 2192 2193 retval.stop = input.LT(-1); 2194 2195 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 2196 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 2197 2198 } 2199 catch (RecognitionException re) { 2200 reportError(re); 2201 recover(input,re); 2202 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 2203 } 2204 finally { 2205 // do for sure before leaving 2206 } 2207 return retval; 2208 } 2209 // $ANTLR end "registers_directive" 2210 2211 2212 public static class param_list_or_id_return extends ParserRuleReturnScope { 2213 CommonTree tree; 2214 @Override getTree()2215 public CommonTree getTree() { return tree; } 2216 }; 2217 2218 2219 // $ANTLR start "param_list_or_id" 2220 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:543:1: param_list_or_id : PARAM_LIST_OR_ID_START ( PRIMITIVE_TYPE )+ PARAM_LIST_OR_ID_END ; param_list_or_id()2221 public final smaliParser.param_list_or_id_return param_list_or_id() throws RecognitionException { 2222 smaliParser.param_list_or_id_return retval = new smaliParser.param_list_or_id_return(); 2223 retval.start = input.LT(1); 2224 2225 CommonTree root_0 = null; 2226 2227 Token PARAM_LIST_OR_ID_START43=null; 2228 Token PRIMITIVE_TYPE44=null; 2229 Token PARAM_LIST_OR_ID_END45=null; 2230 2231 CommonTree PARAM_LIST_OR_ID_START43_tree=null; 2232 CommonTree PRIMITIVE_TYPE44_tree=null; 2233 CommonTree PARAM_LIST_OR_ID_END45_tree=null; 2234 2235 try { 2236 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:544:3: ( PARAM_LIST_OR_ID_START ( PRIMITIVE_TYPE )+ PARAM_LIST_OR_ID_END ) 2237 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:544:5: PARAM_LIST_OR_ID_START ( PRIMITIVE_TYPE )+ PARAM_LIST_OR_ID_END 2238 { 2239 root_0 = (CommonTree)adaptor.nil(); 2240 2241 2242 PARAM_LIST_OR_ID_START43=(Token)match(input,PARAM_LIST_OR_ID_START,FOLLOW_PARAM_LIST_OR_ID_START_in_param_list_or_id1799); 2243 PARAM_LIST_OR_ID_START43_tree = (CommonTree)adaptor.create(PARAM_LIST_OR_ID_START43); 2244 adaptor.addChild(root_0, PARAM_LIST_OR_ID_START43_tree); 2245 2246 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:544:28: ( PRIMITIVE_TYPE )+ 2247 int cnt9=0; 2248 loop9: 2249 while (true) { 2250 int alt9=2; 2251 int LA9_0 = input.LA(1); 2252 if ( (LA9_0==PRIMITIVE_TYPE) ) { 2253 alt9=1; 2254 } 2255 2256 switch (alt9) { 2257 case 1 : 2258 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:544:28: PRIMITIVE_TYPE 2259 { 2260 PRIMITIVE_TYPE44=(Token)match(input,PRIMITIVE_TYPE,FOLLOW_PRIMITIVE_TYPE_in_param_list_or_id1801); 2261 PRIMITIVE_TYPE44_tree = (CommonTree)adaptor.create(PRIMITIVE_TYPE44); 2262 adaptor.addChild(root_0, PRIMITIVE_TYPE44_tree); 2263 2264 } 2265 break; 2266 2267 default : 2268 if ( cnt9 >= 1 ) break loop9; 2269 EarlyExitException eee = new EarlyExitException(9, input); 2270 throw eee; 2271 } 2272 cnt9++; 2273 } 2274 2275 PARAM_LIST_OR_ID_END45=(Token)match(input,PARAM_LIST_OR_ID_END,FOLLOW_PARAM_LIST_OR_ID_END_in_param_list_or_id1804); 2276 PARAM_LIST_OR_ID_END45_tree = (CommonTree)adaptor.create(PARAM_LIST_OR_ID_END45); 2277 adaptor.addChild(root_0, PARAM_LIST_OR_ID_END45_tree); 2278 2279 } 2280 2281 retval.stop = input.LT(-1); 2282 2283 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 2284 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 2285 2286 } 2287 catch (RecognitionException re) { 2288 reportError(re); 2289 recover(input,re); 2290 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 2291 } 2292 finally { 2293 // do for sure before leaving 2294 } 2295 return retval; 2296 } 2297 // $ANTLR end "param_list_or_id" 2298 2299 2300 public static class simple_name_return extends ParserRuleReturnScope { 2301 CommonTree tree; 2302 @Override getTree()2303 public CommonTree getTree() { return tree; } 2304 }; 2305 2306 2307 // $ANTLR start "simple_name" 2308 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:548: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_FORMAT21c_LAMBDA -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_LAMBDA] | INSTRUCTION_FORMAT21c_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_METHOD] | 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_FORMAT22c_STRING -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_STRING] | 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_FORMAT25x -> SIMPLE_NAME[$INSTRUCTION_FORMAT25x] | 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] ); simple_name()2309 public final smaliParser.simple_name_return simple_name() throws RecognitionException { 2310 smaliParser.simple_name_return retval = new smaliParser.simple_name_return(); 2311 retval.start = input.LT(1); 2312 2313 CommonTree root_0 = null; 2314 2315 Token SIMPLE_NAME46=null; 2316 Token ACCESS_SPEC47=null; 2317 Token VERIFICATION_ERROR_TYPE48=null; 2318 Token POSITIVE_INTEGER_LITERAL49=null; 2319 Token NEGATIVE_INTEGER_LITERAL50=null; 2320 Token FLOAT_LITERAL_OR_ID51=null; 2321 Token DOUBLE_LITERAL_OR_ID52=null; 2322 Token BOOL_LITERAL53=null; 2323 Token NULL_LITERAL54=null; 2324 Token REGISTER55=null; 2325 Token PRIMITIVE_TYPE57=null; 2326 Token VOID_TYPE58=null; 2327 Token ANNOTATION_VISIBILITY59=null; 2328 Token INSTRUCTION_FORMAT10t60=null; 2329 Token INSTRUCTION_FORMAT10x61=null; 2330 Token INSTRUCTION_FORMAT10x_ODEX62=null; 2331 Token INSTRUCTION_FORMAT11x63=null; 2332 Token INSTRUCTION_FORMAT12x_OR_ID64=null; 2333 Token INSTRUCTION_FORMAT21c_FIELD65=null; 2334 Token INSTRUCTION_FORMAT21c_FIELD_ODEX66=null; 2335 Token INSTRUCTION_FORMAT21c_STRING67=null; 2336 Token INSTRUCTION_FORMAT21c_TYPE68=null; 2337 Token INSTRUCTION_FORMAT21c_LAMBDA69=null; 2338 Token INSTRUCTION_FORMAT21c_METHOD70=null; 2339 Token INSTRUCTION_FORMAT21t71=null; 2340 Token INSTRUCTION_FORMAT22c_FIELD72=null; 2341 Token INSTRUCTION_FORMAT22c_FIELD_ODEX73=null; 2342 Token INSTRUCTION_FORMAT22c_TYPE74=null; 2343 Token INSTRUCTION_FORMAT22c_STRING75=null; 2344 Token INSTRUCTION_FORMAT22cs_FIELD76=null; 2345 Token INSTRUCTION_FORMAT22s_OR_ID77=null; 2346 Token INSTRUCTION_FORMAT22t78=null; 2347 Token INSTRUCTION_FORMAT23x79=null; 2348 Token INSTRUCTION_FORMAT25x80=null; 2349 Token INSTRUCTION_FORMAT31i_OR_ID81=null; 2350 Token INSTRUCTION_FORMAT31t82=null; 2351 Token INSTRUCTION_FORMAT35c_METHOD83=null; 2352 Token INSTRUCTION_FORMAT35c_METHOD_ODEX84=null; 2353 Token INSTRUCTION_FORMAT35c_TYPE85=null; 2354 Token INSTRUCTION_FORMAT35mi_METHOD86=null; 2355 Token INSTRUCTION_FORMAT35ms_METHOD87=null; 2356 Token INSTRUCTION_FORMAT51l88=null; 2357 ParserRuleReturnScope param_list_or_id56 =null; 2358 2359 CommonTree SIMPLE_NAME46_tree=null; 2360 CommonTree ACCESS_SPEC47_tree=null; 2361 CommonTree VERIFICATION_ERROR_TYPE48_tree=null; 2362 CommonTree POSITIVE_INTEGER_LITERAL49_tree=null; 2363 CommonTree NEGATIVE_INTEGER_LITERAL50_tree=null; 2364 CommonTree FLOAT_LITERAL_OR_ID51_tree=null; 2365 CommonTree DOUBLE_LITERAL_OR_ID52_tree=null; 2366 CommonTree BOOL_LITERAL53_tree=null; 2367 CommonTree NULL_LITERAL54_tree=null; 2368 CommonTree REGISTER55_tree=null; 2369 CommonTree PRIMITIVE_TYPE57_tree=null; 2370 CommonTree VOID_TYPE58_tree=null; 2371 CommonTree ANNOTATION_VISIBILITY59_tree=null; 2372 CommonTree INSTRUCTION_FORMAT10t60_tree=null; 2373 CommonTree INSTRUCTION_FORMAT10x61_tree=null; 2374 CommonTree INSTRUCTION_FORMAT10x_ODEX62_tree=null; 2375 CommonTree INSTRUCTION_FORMAT11x63_tree=null; 2376 CommonTree INSTRUCTION_FORMAT12x_OR_ID64_tree=null; 2377 CommonTree INSTRUCTION_FORMAT21c_FIELD65_tree=null; 2378 CommonTree INSTRUCTION_FORMAT21c_FIELD_ODEX66_tree=null; 2379 CommonTree INSTRUCTION_FORMAT21c_STRING67_tree=null; 2380 CommonTree INSTRUCTION_FORMAT21c_TYPE68_tree=null; 2381 CommonTree INSTRUCTION_FORMAT21c_LAMBDA69_tree=null; 2382 CommonTree INSTRUCTION_FORMAT21c_METHOD70_tree=null; 2383 CommonTree INSTRUCTION_FORMAT21t71_tree=null; 2384 CommonTree INSTRUCTION_FORMAT22c_FIELD72_tree=null; 2385 CommonTree INSTRUCTION_FORMAT22c_FIELD_ODEX73_tree=null; 2386 CommonTree INSTRUCTION_FORMAT22c_TYPE74_tree=null; 2387 CommonTree INSTRUCTION_FORMAT22c_STRING75_tree=null; 2388 CommonTree INSTRUCTION_FORMAT22cs_FIELD76_tree=null; 2389 CommonTree INSTRUCTION_FORMAT22s_OR_ID77_tree=null; 2390 CommonTree INSTRUCTION_FORMAT22t78_tree=null; 2391 CommonTree INSTRUCTION_FORMAT23x79_tree=null; 2392 CommonTree INSTRUCTION_FORMAT25x80_tree=null; 2393 CommonTree INSTRUCTION_FORMAT31i_OR_ID81_tree=null; 2394 CommonTree INSTRUCTION_FORMAT31t82_tree=null; 2395 CommonTree INSTRUCTION_FORMAT35c_METHOD83_tree=null; 2396 CommonTree INSTRUCTION_FORMAT35c_METHOD_ODEX84_tree=null; 2397 CommonTree INSTRUCTION_FORMAT35c_TYPE85_tree=null; 2398 CommonTree INSTRUCTION_FORMAT35mi_METHOD86_tree=null; 2399 CommonTree INSTRUCTION_FORMAT35ms_METHOD87_tree=null; 2400 CommonTree INSTRUCTION_FORMAT51l88_tree=null; 2401 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT25x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT25x"); 2402 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_TYPE"); 2403 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35c_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35c_METHOD"); 2404 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT11x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT11x"); 2405 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21t"); 2406 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35c_TYPE"); 2407 RewriteRuleTokenStream stream_ANNOTATION_VISIBILITY=new RewriteRuleTokenStream(adaptor,"token ANNOTATION_VISIBILITY"); 2408 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT31i_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT31i_OR_ID"); 2409 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_METHOD"); 2410 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22s_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22s_OR_ID"); 2411 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT51l=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT51l"); 2412 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT23x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT23x"); 2413 RewriteRuleTokenStream stream_NULL_LITERAL=new RewriteRuleTokenStream(adaptor,"token NULL_LITERAL"); 2414 RewriteRuleTokenStream stream_BOOL_LITERAL=new RewriteRuleTokenStream(adaptor,"token BOOL_LITERAL"); 2415 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_LAMBDA=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_LAMBDA"); 2416 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_FIELD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_FIELD"); 2417 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35c_METHOD_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35c_METHOD_ODEX"); 2418 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_FIELD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_FIELD"); 2419 RewriteRuleTokenStream stream_ACCESS_SPEC=new RewriteRuleTokenStream(adaptor,"token ACCESS_SPEC"); 2420 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_STRING=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_STRING"); 2421 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT12x_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT12x_OR_ID"); 2422 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35ms_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35ms_METHOD"); 2423 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35mi_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35mi_METHOD"); 2424 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22cs_FIELD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22cs_FIELD"); 2425 RewriteRuleTokenStream stream_VOID_TYPE=new RewriteRuleTokenStream(adaptor,"token VOID_TYPE"); 2426 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT10x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT10x"); 2427 RewriteRuleTokenStream stream_FLOAT_LITERAL_OR_ID=new RewriteRuleTokenStream(adaptor,"token FLOAT_LITERAL_OR_ID"); 2428 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22t"); 2429 RewriteRuleTokenStream stream_PRIMITIVE_TYPE=new RewriteRuleTokenStream(adaptor,"token PRIMITIVE_TYPE"); 2430 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT10x_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT10x_ODEX"); 2431 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT31t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT31t"); 2432 RewriteRuleTokenStream stream_DOUBLE_LITERAL_OR_ID=new RewriteRuleTokenStream(adaptor,"token DOUBLE_LITERAL_OR_ID"); 2433 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_FIELD_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_FIELD_ODEX"); 2434 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT10t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT10t"); 2435 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_STRING=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_STRING"); 2436 RewriteRuleTokenStream stream_NEGATIVE_INTEGER_LITERAL=new RewriteRuleTokenStream(adaptor,"token NEGATIVE_INTEGER_LITERAL"); 2437 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 2438 RewriteRuleTokenStream stream_VERIFICATION_ERROR_TYPE=new RewriteRuleTokenStream(adaptor,"token VERIFICATION_ERROR_TYPE"); 2439 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_TYPE"); 2440 RewriteRuleTokenStream stream_POSITIVE_INTEGER_LITERAL=new RewriteRuleTokenStream(adaptor,"token POSITIVE_INTEGER_LITERAL"); 2441 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_FIELD_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_FIELD_ODEX"); 2442 RewriteRuleSubtreeStream stream_param_list_or_id=new RewriteRuleSubtreeStream(adaptor,"rule param_list_or_id"); 2443 2444 try { 2445 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:549: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_FORMAT21c_LAMBDA -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_LAMBDA] | INSTRUCTION_FORMAT21c_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_METHOD] | 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_FORMAT22c_STRING -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_STRING] | 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_FORMAT25x -> SIMPLE_NAME[$INSTRUCTION_FORMAT25x] | 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] ) 2446 int alt10=43; 2447 switch ( input.LA(1) ) { 2448 case SIMPLE_NAME: 2449 { 2450 alt10=1; 2451 } 2452 break; 2453 case ACCESS_SPEC: 2454 { 2455 alt10=2; 2456 } 2457 break; 2458 case VERIFICATION_ERROR_TYPE: 2459 { 2460 alt10=3; 2461 } 2462 break; 2463 case POSITIVE_INTEGER_LITERAL: 2464 { 2465 alt10=4; 2466 } 2467 break; 2468 case NEGATIVE_INTEGER_LITERAL: 2469 { 2470 alt10=5; 2471 } 2472 break; 2473 case FLOAT_LITERAL_OR_ID: 2474 { 2475 alt10=6; 2476 } 2477 break; 2478 case DOUBLE_LITERAL_OR_ID: 2479 { 2480 alt10=7; 2481 } 2482 break; 2483 case BOOL_LITERAL: 2484 { 2485 alt10=8; 2486 } 2487 break; 2488 case NULL_LITERAL: 2489 { 2490 alt10=9; 2491 } 2492 break; 2493 case REGISTER: 2494 { 2495 alt10=10; 2496 } 2497 break; 2498 case PARAM_LIST_OR_ID_START: 2499 { 2500 alt10=11; 2501 } 2502 break; 2503 case PRIMITIVE_TYPE: 2504 { 2505 alt10=12; 2506 } 2507 break; 2508 case VOID_TYPE: 2509 { 2510 alt10=13; 2511 } 2512 break; 2513 case ANNOTATION_VISIBILITY: 2514 { 2515 alt10=14; 2516 } 2517 break; 2518 case INSTRUCTION_FORMAT10t: 2519 { 2520 alt10=15; 2521 } 2522 break; 2523 case INSTRUCTION_FORMAT10x: 2524 { 2525 alt10=16; 2526 } 2527 break; 2528 case INSTRUCTION_FORMAT10x_ODEX: 2529 { 2530 alt10=17; 2531 } 2532 break; 2533 case INSTRUCTION_FORMAT11x: 2534 { 2535 alt10=18; 2536 } 2537 break; 2538 case INSTRUCTION_FORMAT12x_OR_ID: 2539 { 2540 alt10=19; 2541 } 2542 break; 2543 case INSTRUCTION_FORMAT21c_FIELD: 2544 { 2545 alt10=20; 2546 } 2547 break; 2548 case INSTRUCTION_FORMAT21c_FIELD_ODEX: 2549 { 2550 alt10=21; 2551 } 2552 break; 2553 case INSTRUCTION_FORMAT21c_STRING: 2554 { 2555 alt10=22; 2556 } 2557 break; 2558 case INSTRUCTION_FORMAT21c_TYPE: 2559 { 2560 alt10=23; 2561 } 2562 break; 2563 case INSTRUCTION_FORMAT21c_LAMBDA: 2564 { 2565 alt10=24; 2566 } 2567 break; 2568 case INSTRUCTION_FORMAT21c_METHOD: 2569 { 2570 alt10=25; 2571 } 2572 break; 2573 case INSTRUCTION_FORMAT21t: 2574 { 2575 alt10=26; 2576 } 2577 break; 2578 case INSTRUCTION_FORMAT22c_FIELD: 2579 { 2580 alt10=27; 2581 } 2582 break; 2583 case INSTRUCTION_FORMAT22c_FIELD_ODEX: 2584 { 2585 alt10=28; 2586 } 2587 break; 2588 case INSTRUCTION_FORMAT22c_TYPE: 2589 { 2590 alt10=29; 2591 } 2592 break; 2593 case INSTRUCTION_FORMAT22c_STRING: 2594 { 2595 alt10=30; 2596 } 2597 break; 2598 case INSTRUCTION_FORMAT22cs_FIELD: 2599 { 2600 alt10=31; 2601 } 2602 break; 2603 case INSTRUCTION_FORMAT22s_OR_ID: 2604 { 2605 alt10=32; 2606 } 2607 break; 2608 case INSTRUCTION_FORMAT22t: 2609 { 2610 alt10=33; 2611 } 2612 break; 2613 case INSTRUCTION_FORMAT23x: 2614 { 2615 alt10=34; 2616 } 2617 break; 2618 case INSTRUCTION_FORMAT25x: 2619 { 2620 alt10=35; 2621 } 2622 break; 2623 case INSTRUCTION_FORMAT31i_OR_ID: 2624 { 2625 alt10=36; 2626 } 2627 break; 2628 case INSTRUCTION_FORMAT31t: 2629 { 2630 alt10=37; 2631 } 2632 break; 2633 case INSTRUCTION_FORMAT35c_METHOD: 2634 { 2635 alt10=38; 2636 } 2637 break; 2638 case INSTRUCTION_FORMAT35c_METHOD_ODEX: 2639 { 2640 alt10=39; 2641 } 2642 break; 2643 case INSTRUCTION_FORMAT35c_TYPE: 2644 { 2645 alt10=40; 2646 } 2647 break; 2648 case INSTRUCTION_FORMAT35mi_METHOD: 2649 { 2650 alt10=41; 2651 } 2652 break; 2653 case INSTRUCTION_FORMAT35ms_METHOD: 2654 { 2655 alt10=42; 2656 } 2657 break; 2658 case INSTRUCTION_FORMAT51l: 2659 { 2660 alt10=43; 2661 } 2662 break; 2663 default: 2664 NoViableAltException nvae = 2665 new NoViableAltException("", 10, 0, input); 2666 throw nvae; 2667 } 2668 switch (alt10) { 2669 case 1 : 2670 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:549:5: SIMPLE_NAME 2671 { 2672 root_0 = (CommonTree)adaptor.nil(); 2673 2674 2675 SIMPLE_NAME46=(Token)match(input,SIMPLE_NAME,FOLLOW_SIMPLE_NAME_in_simple_name1816); 2676 SIMPLE_NAME46_tree = (CommonTree)adaptor.create(SIMPLE_NAME46); 2677 adaptor.addChild(root_0, SIMPLE_NAME46_tree); 2678 2679 } 2680 break; 2681 case 2 : 2682 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:550:5: ACCESS_SPEC 2683 { 2684 ACCESS_SPEC47=(Token)match(input,ACCESS_SPEC,FOLLOW_ACCESS_SPEC_in_simple_name1822); 2685 stream_ACCESS_SPEC.add(ACCESS_SPEC47); 2686 2687 // AST REWRITE 2688 // elements: 2689 // token labels: 2690 // rule labels: retval 2691 // token list labels: 2692 // rule list labels: 2693 // wildcard labels: 2694 retval.tree = root_0; 2695 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2696 2697 root_0 = (CommonTree)adaptor.nil(); 2698 // 550:17: -> SIMPLE_NAME[$ACCESS_SPEC] 2699 { 2700 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, ACCESS_SPEC47)); 2701 } 2702 2703 2704 retval.tree = root_0; 2705 2706 } 2707 break; 2708 case 3 : 2709 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:551:5: VERIFICATION_ERROR_TYPE 2710 { 2711 VERIFICATION_ERROR_TYPE48=(Token)match(input,VERIFICATION_ERROR_TYPE,FOLLOW_VERIFICATION_ERROR_TYPE_in_simple_name1833); 2712 stream_VERIFICATION_ERROR_TYPE.add(VERIFICATION_ERROR_TYPE48); 2713 2714 // AST REWRITE 2715 // elements: 2716 // token labels: 2717 // rule labels: retval 2718 // token list labels: 2719 // rule list labels: 2720 // wildcard labels: 2721 retval.tree = root_0; 2722 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2723 2724 root_0 = (CommonTree)adaptor.nil(); 2725 // 551:29: -> SIMPLE_NAME[$VERIFICATION_ERROR_TYPE] 2726 { 2727 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, VERIFICATION_ERROR_TYPE48)); 2728 } 2729 2730 2731 retval.tree = root_0; 2732 2733 } 2734 break; 2735 case 4 : 2736 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:552:5: POSITIVE_INTEGER_LITERAL 2737 { 2738 POSITIVE_INTEGER_LITERAL49=(Token)match(input,POSITIVE_INTEGER_LITERAL,FOLLOW_POSITIVE_INTEGER_LITERAL_in_simple_name1844); 2739 stream_POSITIVE_INTEGER_LITERAL.add(POSITIVE_INTEGER_LITERAL49); 2740 2741 // AST REWRITE 2742 // elements: 2743 // token labels: 2744 // rule labels: retval 2745 // token list labels: 2746 // rule list labels: 2747 // wildcard labels: 2748 retval.tree = root_0; 2749 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2750 2751 root_0 = (CommonTree)adaptor.nil(); 2752 // 552:30: -> SIMPLE_NAME[$POSITIVE_INTEGER_LITERAL] 2753 { 2754 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, POSITIVE_INTEGER_LITERAL49)); 2755 } 2756 2757 2758 retval.tree = root_0; 2759 2760 } 2761 break; 2762 case 5 : 2763 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:553:5: NEGATIVE_INTEGER_LITERAL 2764 { 2765 NEGATIVE_INTEGER_LITERAL50=(Token)match(input,NEGATIVE_INTEGER_LITERAL,FOLLOW_NEGATIVE_INTEGER_LITERAL_in_simple_name1855); 2766 stream_NEGATIVE_INTEGER_LITERAL.add(NEGATIVE_INTEGER_LITERAL50); 2767 2768 // AST REWRITE 2769 // elements: 2770 // token labels: 2771 // rule labels: retval 2772 // token list labels: 2773 // rule list labels: 2774 // wildcard labels: 2775 retval.tree = root_0; 2776 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2777 2778 root_0 = (CommonTree)adaptor.nil(); 2779 // 553:30: -> SIMPLE_NAME[$NEGATIVE_INTEGER_LITERAL] 2780 { 2781 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, NEGATIVE_INTEGER_LITERAL50)); 2782 } 2783 2784 2785 retval.tree = root_0; 2786 2787 } 2788 break; 2789 case 6 : 2790 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:554:5: FLOAT_LITERAL_OR_ID 2791 { 2792 FLOAT_LITERAL_OR_ID51=(Token)match(input,FLOAT_LITERAL_OR_ID,FOLLOW_FLOAT_LITERAL_OR_ID_in_simple_name1866); 2793 stream_FLOAT_LITERAL_OR_ID.add(FLOAT_LITERAL_OR_ID51); 2794 2795 // AST REWRITE 2796 // elements: 2797 // token labels: 2798 // rule labels: retval 2799 // token list labels: 2800 // rule list labels: 2801 // wildcard labels: 2802 retval.tree = root_0; 2803 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2804 2805 root_0 = (CommonTree)adaptor.nil(); 2806 // 554:25: -> SIMPLE_NAME[$FLOAT_LITERAL_OR_ID] 2807 { 2808 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, FLOAT_LITERAL_OR_ID51)); 2809 } 2810 2811 2812 retval.tree = root_0; 2813 2814 } 2815 break; 2816 case 7 : 2817 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:555:5: DOUBLE_LITERAL_OR_ID 2818 { 2819 DOUBLE_LITERAL_OR_ID52=(Token)match(input,DOUBLE_LITERAL_OR_ID,FOLLOW_DOUBLE_LITERAL_OR_ID_in_simple_name1877); 2820 stream_DOUBLE_LITERAL_OR_ID.add(DOUBLE_LITERAL_OR_ID52); 2821 2822 // AST REWRITE 2823 // elements: 2824 // token labels: 2825 // rule labels: retval 2826 // token list labels: 2827 // rule list labels: 2828 // wildcard labels: 2829 retval.tree = root_0; 2830 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2831 2832 root_0 = (CommonTree)adaptor.nil(); 2833 // 555:26: -> SIMPLE_NAME[$DOUBLE_LITERAL_OR_ID] 2834 { 2835 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, DOUBLE_LITERAL_OR_ID52)); 2836 } 2837 2838 2839 retval.tree = root_0; 2840 2841 } 2842 break; 2843 case 8 : 2844 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:556:5: BOOL_LITERAL 2845 { 2846 BOOL_LITERAL53=(Token)match(input,BOOL_LITERAL,FOLLOW_BOOL_LITERAL_in_simple_name1888); 2847 stream_BOOL_LITERAL.add(BOOL_LITERAL53); 2848 2849 // AST REWRITE 2850 // elements: 2851 // token labels: 2852 // rule labels: retval 2853 // token list labels: 2854 // rule list labels: 2855 // wildcard labels: 2856 retval.tree = root_0; 2857 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2858 2859 root_0 = (CommonTree)adaptor.nil(); 2860 // 556:18: -> SIMPLE_NAME[$BOOL_LITERAL] 2861 { 2862 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, BOOL_LITERAL53)); 2863 } 2864 2865 2866 retval.tree = root_0; 2867 2868 } 2869 break; 2870 case 9 : 2871 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:557:5: NULL_LITERAL 2872 { 2873 NULL_LITERAL54=(Token)match(input,NULL_LITERAL,FOLLOW_NULL_LITERAL_in_simple_name1899); 2874 stream_NULL_LITERAL.add(NULL_LITERAL54); 2875 2876 // AST REWRITE 2877 // elements: 2878 // token labels: 2879 // rule labels: retval 2880 // token list labels: 2881 // rule list labels: 2882 // wildcard labels: 2883 retval.tree = root_0; 2884 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2885 2886 root_0 = (CommonTree)adaptor.nil(); 2887 // 557:18: -> SIMPLE_NAME[$NULL_LITERAL] 2888 { 2889 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, NULL_LITERAL54)); 2890 } 2891 2892 2893 retval.tree = root_0; 2894 2895 } 2896 break; 2897 case 10 : 2898 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:558:5: REGISTER 2899 { 2900 REGISTER55=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_simple_name1910); 2901 stream_REGISTER.add(REGISTER55); 2902 2903 // AST REWRITE 2904 // elements: 2905 // token labels: 2906 // rule labels: retval 2907 // token list labels: 2908 // rule list labels: 2909 // wildcard labels: 2910 retval.tree = root_0; 2911 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2912 2913 root_0 = (CommonTree)adaptor.nil(); 2914 // 558:14: -> SIMPLE_NAME[$REGISTER] 2915 { 2916 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, REGISTER55)); 2917 } 2918 2919 2920 retval.tree = root_0; 2921 2922 } 2923 break; 2924 case 11 : 2925 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:559:5: param_list_or_id 2926 { 2927 pushFollow(FOLLOW_param_list_or_id_in_simple_name1921); 2928 param_list_or_id56=param_list_or_id(); 2929 state._fsp--; 2930 2931 stream_param_list_or_id.add(param_list_or_id56.getTree()); 2932 // AST REWRITE 2933 // elements: 2934 // token labels: 2935 // rule labels: retval 2936 // token list labels: 2937 // rule list labels: 2938 // wildcard labels: 2939 retval.tree = root_0; 2940 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2941 2942 root_0 = (CommonTree)adaptor.nil(); 2943 // 559:22: -> 2944 { 2945 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)) ); 2946 } 2947 2948 2949 retval.tree = root_0; 2950 2951 } 2952 break; 2953 case 12 : 2954 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:560:5: PRIMITIVE_TYPE 2955 { 2956 PRIMITIVE_TYPE57=(Token)match(input,PRIMITIVE_TYPE,FOLLOW_PRIMITIVE_TYPE_in_simple_name1931); 2957 stream_PRIMITIVE_TYPE.add(PRIMITIVE_TYPE57); 2958 2959 // AST REWRITE 2960 // elements: 2961 // token labels: 2962 // rule labels: retval 2963 // token list labels: 2964 // rule list labels: 2965 // wildcard labels: 2966 retval.tree = root_0; 2967 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2968 2969 root_0 = (CommonTree)adaptor.nil(); 2970 // 560:20: -> SIMPLE_NAME[$PRIMITIVE_TYPE] 2971 { 2972 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, PRIMITIVE_TYPE57)); 2973 } 2974 2975 2976 retval.tree = root_0; 2977 2978 } 2979 break; 2980 case 13 : 2981 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:561:5: VOID_TYPE 2982 { 2983 VOID_TYPE58=(Token)match(input,VOID_TYPE,FOLLOW_VOID_TYPE_in_simple_name1942); 2984 stream_VOID_TYPE.add(VOID_TYPE58); 2985 2986 // AST REWRITE 2987 // elements: 2988 // token labels: 2989 // rule labels: retval 2990 // token list labels: 2991 // rule list labels: 2992 // wildcard labels: 2993 retval.tree = root_0; 2994 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2995 2996 root_0 = (CommonTree)adaptor.nil(); 2997 // 561:15: -> SIMPLE_NAME[$VOID_TYPE] 2998 { 2999 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, VOID_TYPE58)); 3000 } 3001 3002 3003 retval.tree = root_0; 3004 3005 } 3006 break; 3007 case 14 : 3008 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:562:5: ANNOTATION_VISIBILITY 3009 { 3010 ANNOTATION_VISIBILITY59=(Token)match(input,ANNOTATION_VISIBILITY,FOLLOW_ANNOTATION_VISIBILITY_in_simple_name1953); 3011 stream_ANNOTATION_VISIBILITY.add(ANNOTATION_VISIBILITY59); 3012 3013 // AST REWRITE 3014 // elements: 3015 // token labels: 3016 // rule labels: retval 3017 // token list labels: 3018 // rule list labels: 3019 // wildcard labels: 3020 retval.tree = root_0; 3021 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3022 3023 root_0 = (CommonTree)adaptor.nil(); 3024 // 562:27: -> SIMPLE_NAME[$ANNOTATION_VISIBILITY] 3025 { 3026 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, ANNOTATION_VISIBILITY59)); 3027 } 3028 3029 3030 retval.tree = root_0; 3031 3032 } 3033 break; 3034 case 15 : 3035 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:563:5: INSTRUCTION_FORMAT10t 3036 { 3037 INSTRUCTION_FORMAT10t60=(Token)match(input,INSTRUCTION_FORMAT10t,FOLLOW_INSTRUCTION_FORMAT10t_in_simple_name1964); 3038 stream_INSTRUCTION_FORMAT10t.add(INSTRUCTION_FORMAT10t60); 3039 3040 // AST REWRITE 3041 // elements: 3042 // token labels: 3043 // rule labels: retval 3044 // token list labels: 3045 // rule list labels: 3046 // wildcard labels: 3047 retval.tree = root_0; 3048 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3049 3050 root_0 = (CommonTree)adaptor.nil(); 3051 // 563:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT10t] 3052 { 3053 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT10t60)); 3054 } 3055 3056 3057 retval.tree = root_0; 3058 3059 } 3060 break; 3061 case 16 : 3062 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:564:5: INSTRUCTION_FORMAT10x 3063 { 3064 INSTRUCTION_FORMAT10x61=(Token)match(input,INSTRUCTION_FORMAT10x,FOLLOW_INSTRUCTION_FORMAT10x_in_simple_name1975); 3065 stream_INSTRUCTION_FORMAT10x.add(INSTRUCTION_FORMAT10x61); 3066 3067 // AST REWRITE 3068 // elements: 3069 // token labels: 3070 // rule labels: retval 3071 // token list labels: 3072 // rule list labels: 3073 // wildcard labels: 3074 retval.tree = root_0; 3075 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3076 3077 root_0 = (CommonTree)adaptor.nil(); 3078 // 564:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT10x] 3079 { 3080 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT10x61)); 3081 } 3082 3083 3084 retval.tree = root_0; 3085 3086 } 3087 break; 3088 case 17 : 3089 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:565:5: INSTRUCTION_FORMAT10x_ODEX 3090 { 3091 INSTRUCTION_FORMAT10x_ODEX62=(Token)match(input,INSTRUCTION_FORMAT10x_ODEX,FOLLOW_INSTRUCTION_FORMAT10x_ODEX_in_simple_name1986); 3092 stream_INSTRUCTION_FORMAT10x_ODEX.add(INSTRUCTION_FORMAT10x_ODEX62); 3093 3094 // AST REWRITE 3095 // elements: 3096 // token labels: 3097 // rule labels: retval 3098 // token list labels: 3099 // rule list labels: 3100 // wildcard labels: 3101 retval.tree = root_0; 3102 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3103 3104 root_0 = (CommonTree)adaptor.nil(); 3105 // 565:32: -> SIMPLE_NAME[$INSTRUCTION_FORMAT10x_ODEX] 3106 { 3107 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT10x_ODEX62)); 3108 } 3109 3110 3111 retval.tree = root_0; 3112 3113 } 3114 break; 3115 case 18 : 3116 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:566:5: INSTRUCTION_FORMAT11x 3117 { 3118 INSTRUCTION_FORMAT11x63=(Token)match(input,INSTRUCTION_FORMAT11x,FOLLOW_INSTRUCTION_FORMAT11x_in_simple_name1997); 3119 stream_INSTRUCTION_FORMAT11x.add(INSTRUCTION_FORMAT11x63); 3120 3121 // AST REWRITE 3122 // elements: 3123 // token labels: 3124 // rule labels: retval 3125 // token list labels: 3126 // rule list labels: 3127 // wildcard labels: 3128 retval.tree = root_0; 3129 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3130 3131 root_0 = (CommonTree)adaptor.nil(); 3132 // 566:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT11x] 3133 { 3134 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT11x63)); 3135 } 3136 3137 3138 retval.tree = root_0; 3139 3140 } 3141 break; 3142 case 19 : 3143 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:567:5: INSTRUCTION_FORMAT12x_OR_ID 3144 { 3145 INSTRUCTION_FORMAT12x_OR_ID64=(Token)match(input,INSTRUCTION_FORMAT12x_OR_ID,FOLLOW_INSTRUCTION_FORMAT12x_OR_ID_in_simple_name2008); 3146 stream_INSTRUCTION_FORMAT12x_OR_ID.add(INSTRUCTION_FORMAT12x_OR_ID64); 3147 3148 // AST REWRITE 3149 // elements: 3150 // token labels: 3151 // rule labels: retval 3152 // token list labels: 3153 // rule list labels: 3154 // wildcard labels: 3155 retval.tree = root_0; 3156 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3157 3158 root_0 = (CommonTree)adaptor.nil(); 3159 // 567:33: -> SIMPLE_NAME[$INSTRUCTION_FORMAT12x_OR_ID] 3160 { 3161 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT12x_OR_ID64)); 3162 } 3163 3164 3165 retval.tree = root_0; 3166 3167 } 3168 break; 3169 case 20 : 3170 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:568:5: INSTRUCTION_FORMAT21c_FIELD 3171 { 3172 INSTRUCTION_FORMAT21c_FIELD65=(Token)match(input,INSTRUCTION_FORMAT21c_FIELD,FOLLOW_INSTRUCTION_FORMAT21c_FIELD_in_simple_name2019); 3173 stream_INSTRUCTION_FORMAT21c_FIELD.add(INSTRUCTION_FORMAT21c_FIELD65); 3174 3175 // AST REWRITE 3176 // elements: 3177 // token labels: 3178 // rule labels: retval 3179 // token list labels: 3180 // rule list labels: 3181 // wildcard labels: 3182 retval.tree = root_0; 3183 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3184 3185 root_0 = (CommonTree)adaptor.nil(); 3186 // 568:33: -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_FIELD] 3187 { 3188 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT21c_FIELD65)); 3189 } 3190 3191 3192 retval.tree = root_0; 3193 3194 } 3195 break; 3196 case 21 : 3197 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:569:5: INSTRUCTION_FORMAT21c_FIELD_ODEX 3198 { 3199 INSTRUCTION_FORMAT21c_FIELD_ODEX66=(Token)match(input,INSTRUCTION_FORMAT21c_FIELD_ODEX,FOLLOW_INSTRUCTION_FORMAT21c_FIELD_ODEX_in_simple_name2030); 3200 stream_INSTRUCTION_FORMAT21c_FIELD_ODEX.add(INSTRUCTION_FORMAT21c_FIELD_ODEX66); 3201 3202 // AST REWRITE 3203 // elements: 3204 // token labels: 3205 // rule labels: retval 3206 // token list labels: 3207 // rule list labels: 3208 // wildcard labels: 3209 retval.tree = root_0; 3210 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3211 3212 root_0 = (CommonTree)adaptor.nil(); 3213 // 569:38: -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_FIELD_ODEX] 3214 { 3215 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT21c_FIELD_ODEX66)); 3216 } 3217 3218 3219 retval.tree = root_0; 3220 3221 } 3222 break; 3223 case 22 : 3224 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:570:5: INSTRUCTION_FORMAT21c_STRING 3225 { 3226 INSTRUCTION_FORMAT21c_STRING67=(Token)match(input,INSTRUCTION_FORMAT21c_STRING,FOLLOW_INSTRUCTION_FORMAT21c_STRING_in_simple_name2041); 3227 stream_INSTRUCTION_FORMAT21c_STRING.add(INSTRUCTION_FORMAT21c_STRING67); 3228 3229 // AST REWRITE 3230 // elements: 3231 // token labels: 3232 // rule labels: retval 3233 // token list labels: 3234 // rule list labels: 3235 // wildcard labels: 3236 retval.tree = root_0; 3237 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3238 3239 root_0 = (CommonTree)adaptor.nil(); 3240 // 570:34: -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_STRING] 3241 { 3242 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT21c_STRING67)); 3243 } 3244 3245 3246 retval.tree = root_0; 3247 3248 } 3249 break; 3250 case 23 : 3251 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:571:5: INSTRUCTION_FORMAT21c_TYPE 3252 { 3253 INSTRUCTION_FORMAT21c_TYPE68=(Token)match(input,INSTRUCTION_FORMAT21c_TYPE,FOLLOW_INSTRUCTION_FORMAT21c_TYPE_in_simple_name2052); 3254 stream_INSTRUCTION_FORMAT21c_TYPE.add(INSTRUCTION_FORMAT21c_TYPE68); 3255 3256 // AST REWRITE 3257 // elements: 3258 // token labels: 3259 // rule labels: retval 3260 // token list labels: 3261 // rule list labels: 3262 // wildcard labels: 3263 retval.tree = root_0; 3264 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3265 3266 root_0 = (CommonTree)adaptor.nil(); 3267 // 571:32: -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_TYPE] 3268 { 3269 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT21c_TYPE68)); 3270 } 3271 3272 3273 retval.tree = root_0; 3274 3275 } 3276 break; 3277 case 24 : 3278 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:572:5: INSTRUCTION_FORMAT21c_LAMBDA 3279 { 3280 INSTRUCTION_FORMAT21c_LAMBDA69=(Token)match(input,INSTRUCTION_FORMAT21c_LAMBDA,FOLLOW_INSTRUCTION_FORMAT21c_LAMBDA_in_simple_name2063); 3281 stream_INSTRUCTION_FORMAT21c_LAMBDA.add(INSTRUCTION_FORMAT21c_LAMBDA69); 3282 3283 // AST REWRITE 3284 // elements: 3285 // token labels: 3286 // rule labels: retval 3287 // token list labels: 3288 // rule list labels: 3289 // wildcard labels: 3290 retval.tree = root_0; 3291 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3292 3293 root_0 = (CommonTree)adaptor.nil(); 3294 // 572:34: -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_LAMBDA] 3295 { 3296 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT21c_LAMBDA69)); 3297 } 3298 3299 3300 retval.tree = root_0; 3301 3302 } 3303 break; 3304 case 25 : 3305 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:573:5: INSTRUCTION_FORMAT21c_METHOD 3306 { 3307 INSTRUCTION_FORMAT21c_METHOD70=(Token)match(input,INSTRUCTION_FORMAT21c_METHOD,FOLLOW_INSTRUCTION_FORMAT21c_METHOD_in_simple_name2074); 3308 stream_INSTRUCTION_FORMAT21c_METHOD.add(INSTRUCTION_FORMAT21c_METHOD70); 3309 3310 // AST REWRITE 3311 // elements: 3312 // token labels: 3313 // rule labels: retval 3314 // token list labels: 3315 // rule list labels: 3316 // wildcard labels: 3317 retval.tree = root_0; 3318 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3319 3320 root_0 = (CommonTree)adaptor.nil(); 3321 // 573:34: -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_METHOD] 3322 { 3323 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT21c_METHOD70)); 3324 } 3325 3326 3327 retval.tree = root_0; 3328 3329 } 3330 break; 3331 case 26 : 3332 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:574:5: INSTRUCTION_FORMAT21t 3333 { 3334 INSTRUCTION_FORMAT21t71=(Token)match(input,INSTRUCTION_FORMAT21t,FOLLOW_INSTRUCTION_FORMAT21t_in_simple_name2085); 3335 stream_INSTRUCTION_FORMAT21t.add(INSTRUCTION_FORMAT21t71); 3336 3337 // AST REWRITE 3338 // elements: 3339 // token labels: 3340 // rule labels: retval 3341 // token list labels: 3342 // rule list labels: 3343 // wildcard labels: 3344 retval.tree = root_0; 3345 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3346 3347 root_0 = (CommonTree)adaptor.nil(); 3348 // 574:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT21t] 3349 { 3350 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT21t71)); 3351 } 3352 3353 3354 retval.tree = root_0; 3355 3356 } 3357 break; 3358 case 27 : 3359 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:575:5: INSTRUCTION_FORMAT22c_FIELD 3360 { 3361 INSTRUCTION_FORMAT22c_FIELD72=(Token)match(input,INSTRUCTION_FORMAT22c_FIELD,FOLLOW_INSTRUCTION_FORMAT22c_FIELD_in_simple_name2096); 3362 stream_INSTRUCTION_FORMAT22c_FIELD.add(INSTRUCTION_FORMAT22c_FIELD72); 3363 3364 // AST REWRITE 3365 // elements: 3366 // token labels: 3367 // rule labels: retval 3368 // token list labels: 3369 // rule list labels: 3370 // wildcard labels: 3371 retval.tree = root_0; 3372 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3373 3374 root_0 = (CommonTree)adaptor.nil(); 3375 // 575:33: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_FIELD] 3376 { 3377 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22c_FIELD72)); 3378 } 3379 3380 3381 retval.tree = root_0; 3382 3383 } 3384 break; 3385 case 28 : 3386 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:576:5: INSTRUCTION_FORMAT22c_FIELD_ODEX 3387 { 3388 INSTRUCTION_FORMAT22c_FIELD_ODEX73=(Token)match(input,INSTRUCTION_FORMAT22c_FIELD_ODEX,FOLLOW_INSTRUCTION_FORMAT22c_FIELD_ODEX_in_simple_name2107); 3389 stream_INSTRUCTION_FORMAT22c_FIELD_ODEX.add(INSTRUCTION_FORMAT22c_FIELD_ODEX73); 3390 3391 // AST REWRITE 3392 // elements: 3393 // token labels: 3394 // rule labels: retval 3395 // token list labels: 3396 // rule list labels: 3397 // wildcard labels: 3398 retval.tree = root_0; 3399 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3400 3401 root_0 = (CommonTree)adaptor.nil(); 3402 // 576:38: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_FIELD_ODEX] 3403 { 3404 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22c_FIELD_ODEX73)); 3405 } 3406 3407 3408 retval.tree = root_0; 3409 3410 } 3411 break; 3412 case 29 : 3413 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:577:5: INSTRUCTION_FORMAT22c_TYPE 3414 { 3415 INSTRUCTION_FORMAT22c_TYPE74=(Token)match(input,INSTRUCTION_FORMAT22c_TYPE,FOLLOW_INSTRUCTION_FORMAT22c_TYPE_in_simple_name2118); 3416 stream_INSTRUCTION_FORMAT22c_TYPE.add(INSTRUCTION_FORMAT22c_TYPE74); 3417 3418 // AST REWRITE 3419 // elements: 3420 // token labels: 3421 // rule labels: retval 3422 // token list labels: 3423 // rule list labels: 3424 // wildcard labels: 3425 retval.tree = root_0; 3426 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3427 3428 root_0 = (CommonTree)adaptor.nil(); 3429 // 577:32: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_TYPE] 3430 { 3431 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22c_TYPE74)); 3432 } 3433 3434 3435 retval.tree = root_0; 3436 3437 } 3438 break; 3439 case 30 : 3440 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:578:5: INSTRUCTION_FORMAT22c_STRING 3441 { 3442 INSTRUCTION_FORMAT22c_STRING75=(Token)match(input,INSTRUCTION_FORMAT22c_STRING,FOLLOW_INSTRUCTION_FORMAT22c_STRING_in_simple_name2129); 3443 stream_INSTRUCTION_FORMAT22c_STRING.add(INSTRUCTION_FORMAT22c_STRING75); 3444 3445 // AST REWRITE 3446 // elements: 3447 // token labels: 3448 // rule labels: retval 3449 // token list labels: 3450 // rule list labels: 3451 // wildcard labels: 3452 retval.tree = root_0; 3453 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3454 3455 root_0 = (CommonTree)adaptor.nil(); 3456 // 578:34: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_STRING] 3457 { 3458 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22c_STRING75)); 3459 } 3460 3461 3462 retval.tree = root_0; 3463 3464 } 3465 break; 3466 case 31 : 3467 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:579:5: INSTRUCTION_FORMAT22cs_FIELD 3468 { 3469 INSTRUCTION_FORMAT22cs_FIELD76=(Token)match(input,INSTRUCTION_FORMAT22cs_FIELD,FOLLOW_INSTRUCTION_FORMAT22cs_FIELD_in_simple_name2140); 3470 stream_INSTRUCTION_FORMAT22cs_FIELD.add(INSTRUCTION_FORMAT22cs_FIELD76); 3471 3472 // AST REWRITE 3473 // elements: 3474 // token labels: 3475 // rule labels: retval 3476 // token list labels: 3477 // rule list labels: 3478 // wildcard labels: 3479 retval.tree = root_0; 3480 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3481 3482 root_0 = (CommonTree)adaptor.nil(); 3483 // 579:34: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22cs_FIELD] 3484 { 3485 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22cs_FIELD76)); 3486 } 3487 3488 3489 retval.tree = root_0; 3490 3491 } 3492 break; 3493 case 32 : 3494 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:580:5: INSTRUCTION_FORMAT22s_OR_ID 3495 { 3496 INSTRUCTION_FORMAT22s_OR_ID77=(Token)match(input,INSTRUCTION_FORMAT22s_OR_ID,FOLLOW_INSTRUCTION_FORMAT22s_OR_ID_in_simple_name2151); 3497 stream_INSTRUCTION_FORMAT22s_OR_ID.add(INSTRUCTION_FORMAT22s_OR_ID77); 3498 3499 // AST REWRITE 3500 // elements: 3501 // token labels: 3502 // rule labels: retval 3503 // token list labels: 3504 // rule list labels: 3505 // wildcard labels: 3506 retval.tree = root_0; 3507 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3508 3509 root_0 = (CommonTree)adaptor.nil(); 3510 // 580:33: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22s_OR_ID] 3511 { 3512 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22s_OR_ID77)); 3513 } 3514 3515 3516 retval.tree = root_0; 3517 3518 } 3519 break; 3520 case 33 : 3521 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:581:5: INSTRUCTION_FORMAT22t 3522 { 3523 INSTRUCTION_FORMAT22t78=(Token)match(input,INSTRUCTION_FORMAT22t,FOLLOW_INSTRUCTION_FORMAT22t_in_simple_name2162); 3524 stream_INSTRUCTION_FORMAT22t.add(INSTRUCTION_FORMAT22t78); 3525 3526 // AST REWRITE 3527 // elements: 3528 // token labels: 3529 // rule labels: retval 3530 // token list labels: 3531 // rule list labels: 3532 // wildcard labels: 3533 retval.tree = root_0; 3534 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3535 3536 root_0 = (CommonTree)adaptor.nil(); 3537 // 581:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22t] 3538 { 3539 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22t78)); 3540 } 3541 3542 3543 retval.tree = root_0; 3544 3545 } 3546 break; 3547 case 34 : 3548 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:582:5: INSTRUCTION_FORMAT23x 3549 { 3550 INSTRUCTION_FORMAT23x79=(Token)match(input,INSTRUCTION_FORMAT23x,FOLLOW_INSTRUCTION_FORMAT23x_in_simple_name2173); 3551 stream_INSTRUCTION_FORMAT23x.add(INSTRUCTION_FORMAT23x79); 3552 3553 // AST REWRITE 3554 // elements: 3555 // token labels: 3556 // rule labels: retval 3557 // token list labels: 3558 // rule list labels: 3559 // wildcard labels: 3560 retval.tree = root_0; 3561 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3562 3563 root_0 = (CommonTree)adaptor.nil(); 3564 // 582:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT23x] 3565 { 3566 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT23x79)); 3567 } 3568 3569 3570 retval.tree = root_0; 3571 3572 } 3573 break; 3574 case 35 : 3575 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:583:5: INSTRUCTION_FORMAT25x 3576 { 3577 INSTRUCTION_FORMAT25x80=(Token)match(input,INSTRUCTION_FORMAT25x,FOLLOW_INSTRUCTION_FORMAT25x_in_simple_name2184); 3578 stream_INSTRUCTION_FORMAT25x.add(INSTRUCTION_FORMAT25x80); 3579 3580 // AST REWRITE 3581 // elements: 3582 // token labels: 3583 // rule labels: retval 3584 // token list labels: 3585 // rule list labels: 3586 // wildcard labels: 3587 retval.tree = root_0; 3588 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3589 3590 root_0 = (CommonTree)adaptor.nil(); 3591 // 583:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT25x] 3592 { 3593 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT25x80)); 3594 } 3595 3596 3597 retval.tree = root_0; 3598 3599 } 3600 break; 3601 case 36 : 3602 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:584:5: INSTRUCTION_FORMAT31i_OR_ID 3603 { 3604 INSTRUCTION_FORMAT31i_OR_ID81=(Token)match(input,INSTRUCTION_FORMAT31i_OR_ID,FOLLOW_INSTRUCTION_FORMAT31i_OR_ID_in_simple_name2195); 3605 stream_INSTRUCTION_FORMAT31i_OR_ID.add(INSTRUCTION_FORMAT31i_OR_ID81); 3606 3607 // AST REWRITE 3608 // elements: 3609 // token labels: 3610 // rule labels: retval 3611 // token list labels: 3612 // rule list labels: 3613 // wildcard labels: 3614 retval.tree = root_0; 3615 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3616 3617 root_0 = (CommonTree)adaptor.nil(); 3618 // 584:33: -> SIMPLE_NAME[$INSTRUCTION_FORMAT31i_OR_ID] 3619 { 3620 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT31i_OR_ID81)); 3621 } 3622 3623 3624 retval.tree = root_0; 3625 3626 } 3627 break; 3628 case 37 : 3629 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:585:5: INSTRUCTION_FORMAT31t 3630 { 3631 INSTRUCTION_FORMAT31t82=(Token)match(input,INSTRUCTION_FORMAT31t,FOLLOW_INSTRUCTION_FORMAT31t_in_simple_name2206); 3632 stream_INSTRUCTION_FORMAT31t.add(INSTRUCTION_FORMAT31t82); 3633 3634 // AST REWRITE 3635 // elements: 3636 // token labels: 3637 // rule labels: retval 3638 // token list labels: 3639 // rule list labels: 3640 // wildcard labels: 3641 retval.tree = root_0; 3642 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3643 3644 root_0 = (CommonTree)adaptor.nil(); 3645 // 585:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT31t] 3646 { 3647 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT31t82)); 3648 } 3649 3650 3651 retval.tree = root_0; 3652 3653 } 3654 break; 3655 case 38 : 3656 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:586:5: INSTRUCTION_FORMAT35c_METHOD 3657 { 3658 INSTRUCTION_FORMAT35c_METHOD83=(Token)match(input,INSTRUCTION_FORMAT35c_METHOD,FOLLOW_INSTRUCTION_FORMAT35c_METHOD_in_simple_name2217); 3659 stream_INSTRUCTION_FORMAT35c_METHOD.add(INSTRUCTION_FORMAT35c_METHOD83); 3660 3661 // AST REWRITE 3662 // elements: 3663 // token labels: 3664 // rule labels: retval 3665 // token list labels: 3666 // rule list labels: 3667 // wildcard labels: 3668 retval.tree = root_0; 3669 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3670 3671 root_0 = (CommonTree)adaptor.nil(); 3672 // 586:34: -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_METHOD] 3673 { 3674 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT35c_METHOD83)); 3675 } 3676 3677 3678 retval.tree = root_0; 3679 3680 } 3681 break; 3682 case 39 : 3683 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:587:5: INSTRUCTION_FORMAT35c_METHOD_ODEX 3684 { 3685 INSTRUCTION_FORMAT35c_METHOD_ODEX84=(Token)match(input,INSTRUCTION_FORMAT35c_METHOD_ODEX,FOLLOW_INSTRUCTION_FORMAT35c_METHOD_ODEX_in_simple_name2228); 3686 stream_INSTRUCTION_FORMAT35c_METHOD_ODEX.add(INSTRUCTION_FORMAT35c_METHOD_ODEX84); 3687 3688 // AST REWRITE 3689 // elements: 3690 // token labels: 3691 // rule labels: retval 3692 // token list labels: 3693 // rule list labels: 3694 // wildcard labels: 3695 retval.tree = root_0; 3696 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3697 3698 root_0 = (CommonTree)adaptor.nil(); 3699 // 587:39: -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_METHOD_ODEX] 3700 { 3701 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT35c_METHOD_ODEX84)); 3702 } 3703 3704 3705 retval.tree = root_0; 3706 3707 } 3708 break; 3709 case 40 : 3710 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:588:5: INSTRUCTION_FORMAT35c_TYPE 3711 { 3712 INSTRUCTION_FORMAT35c_TYPE85=(Token)match(input,INSTRUCTION_FORMAT35c_TYPE,FOLLOW_INSTRUCTION_FORMAT35c_TYPE_in_simple_name2239); 3713 stream_INSTRUCTION_FORMAT35c_TYPE.add(INSTRUCTION_FORMAT35c_TYPE85); 3714 3715 // AST REWRITE 3716 // elements: 3717 // token labels: 3718 // rule labels: retval 3719 // token list labels: 3720 // rule list labels: 3721 // wildcard labels: 3722 retval.tree = root_0; 3723 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3724 3725 root_0 = (CommonTree)adaptor.nil(); 3726 // 588:32: -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_TYPE] 3727 { 3728 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT35c_TYPE85)); 3729 } 3730 3731 3732 retval.tree = root_0; 3733 3734 } 3735 break; 3736 case 41 : 3737 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:589:5: INSTRUCTION_FORMAT35mi_METHOD 3738 { 3739 INSTRUCTION_FORMAT35mi_METHOD86=(Token)match(input,INSTRUCTION_FORMAT35mi_METHOD,FOLLOW_INSTRUCTION_FORMAT35mi_METHOD_in_simple_name2250); 3740 stream_INSTRUCTION_FORMAT35mi_METHOD.add(INSTRUCTION_FORMAT35mi_METHOD86); 3741 3742 // AST REWRITE 3743 // elements: 3744 // token labels: 3745 // rule labels: retval 3746 // token list labels: 3747 // rule list labels: 3748 // wildcard labels: 3749 retval.tree = root_0; 3750 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3751 3752 root_0 = (CommonTree)adaptor.nil(); 3753 // 589:35: -> SIMPLE_NAME[$INSTRUCTION_FORMAT35mi_METHOD] 3754 { 3755 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT35mi_METHOD86)); 3756 } 3757 3758 3759 retval.tree = root_0; 3760 3761 } 3762 break; 3763 case 42 : 3764 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:590:5: INSTRUCTION_FORMAT35ms_METHOD 3765 { 3766 INSTRUCTION_FORMAT35ms_METHOD87=(Token)match(input,INSTRUCTION_FORMAT35ms_METHOD,FOLLOW_INSTRUCTION_FORMAT35ms_METHOD_in_simple_name2261); 3767 stream_INSTRUCTION_FORMAT35ms_METHOD.add(INSTRUCTION_FORMAT35ms_METHOD87); 3768 3769 // AST REWRITE 3770 // elements: 3771 // token labels: 3772 // rule labels: retval 3773 // token list labels: 3774 // rule list labels: 3775 // wildcard labels: 3776 retval.tree = root_0; 3777 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3778 3779 root_0 = (CommonTree)adaptor.nil(); 3780 // 590:35: -> SIMPLE_NAME[$INSTRUCTION_FORMAT35ms_METHOD] 3781 { 3782 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT35ms_METHOD87)); 3783 } 3784 3785 3786 retval.tree = root_0; 3787 3788 } 3789 break; 3790 case 43 : 3791 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:591:5: INSTRUCTION_FORMAT51l 3792 { 3793 INSTRUCTION_FORMAT51l88=(Token)match(input,INSTRUCTION_FORMAT51l,FOLLOW_INSTRUCTION_FORMAT51l_in_simple_name2272); 3794 stream_INSTRUCTION_FORMAT51l.add(INSTRUCTION_FORMAT51l88); 3795 3796 // AST REWRITE 3797 // elements: 3798 // token labels: 3799 // rule labels: retval 3800 // token list labels: 3801 // rule list labels: 3802 // wildcard labels: 3803 retval.tree = root_0; 3804 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3805 3806 root_0 = (CommonTree)adaptor.nil(); 3807 // 591:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT51l] 3808 { 3809 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT51l88)); 3810 } 3811 3812 3813 retval.tree = root_0; 3814 3815 } 3816 break; 3817 3818 } 3819 retval.stop = input.LT(-1); 3820 3821 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 3822 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 3823 3824 } 3825 catch (RecognitionException re) { 3826 reportError(re); 3827 recover(input,re); 3828 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 3829 } 3830 finally { 3831 // do for sure before leaving 3832 } 3833 return retval; 3834 } 3835 // $ANTLR end "simple_name" 3836 3837 3838 public static class member_name_return extends ParserRuleReturnScope { 3839 CommonTree tree; 3840 @Override getTree()3841 public CommonTree getTree() { return tree; } 3842 }; 3843 3844 3845 // $ANTLR start "member_name" 3846 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:593:1: member_name : ( simple_name | MEMBER_NAME -> SIMPLE_NAME[$MEMBER_NAME] ); member_name()3847 public final smaliParser.member_name_return member_name() throws RecognitionException { 3848 smaliParser.member_name_return retval = new smaliParser.member_name_return(); 3849 retval.start = input.LT(1); 3850 3851 CommonTree root_0 = null; 3852 3853 Token MEMBER_NAME90=null; 3854 ParserRuleReturnScope simple_name89 =null; 3855 3856 CommonTree MEMBER_NAME90_tree=null; 3857 RewriteRuleTokenStream stream_MEMBER_NAME=new RewriteRuleTokenStream(adaptor,"token MEMBER_NAME"); 3858 3859 try { 3860 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:594:3: ( simple_name | MEMBER_NAME -> SIMPLE_NAME[$MEMBER_NAME] ) 3861 int alt11=2; 3862 int LA11_0 = input.LA(1); 3863 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_FORMAT25x)||(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)) ) { 3864 alt11=1; 3865 } 3866 else if ( (LA11_0==MEMBER_NAME) ) { 3867 alt11=2; 3868 } 3869 3870 else { 3871 NoViableAltException nvae = 3872 new NoViableAltException("", 11, 0, input); 3873 throw nvae; 3874 } 3875 3876 switch (alt11) { 3877 case 1 : 3878 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:594:5: simple_name 3879 { 3880 root_0 = (CommonTree)adaptor.nil(); 3881 3882 3883 pushFollow(FOLLOW_simple_name_in_member_name2287); 3884 simple_name89=simple_name(); 3885 state._fsp--; 3886 3887 adaptor.addChild(root_0, simple_name89.getTree()); 3888 3889 } 3890 break; 3891 case 2 : 3892 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:595:5: MEMBER_NAME 3893 { 3894 MEMBER_NAME90=(Token)match(input,MEMBER_NAME,FOLLOW_MEMBER_NAME_in_member_name2293); 3895 stream_MEMBER_NAME.add(MEMBER_NAME90); 3896 3897 // AST REWRITE 3898 // elements: 3899 // token labels: 3900 // rule labels: retval 3901 // token list labels: 3902 // rule list labels: 3903 // wildcard labels: 3904 retval.tree = root_0; 3905 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3906 3907 root_0 = (CommonTree)adaptor.nil(); 3908 // 595:17: -> SIMPLE_NAME[$MEMBER_NAME] 3909 { 3910 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, MEMBER_NAME90)); 3911 } 3912 3913 3914 retval.tree = root_0; 3915 3916 } 3917 break; 3918 3919 } 3920 retval.stop = input.LT(-1); 3921 3922 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 3923 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 3924 3925 } 3926 catch (RecognitionException re) { 3927 reportError(re); 3928 recover(input,re); 3929 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 3930 } 3931 finally { 3932 // do for sure before leaving 3933 } 3934 return retval; 3935 } 3936 // $ANTLR end "member_name" 3937 3938 3939 public static class method_prototype_return extends ParserRuleReturnScope { 3940 CommonTree tree; 3941 @Override getTree()3942 public CommonTree getTree() { return tree; } 3943 }; 3944 3945 3946 // $ANTLR start "method_prototype" 3947 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:597: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 )? ) ; method_prototype()3948 public final smaliParser.method_prototype_return method_prototype() throws RecognitionException { 3949 smaliParser.method_prototype_return retval = new smaliParser.method_prototype_return(); 3950 retval.start = input.LT(1); 3951 3952 CommonTree root_0 = null; 3953 3954 Token OPEN_PAREN91=null; 3955 Token CLOSE_PAREN93=null; 3956 ParserRuleReturnScope param_list92 =null; 3957 ParserRuleReturnScope type_descriptor94 =null; 3958 3959 CommonTree OPEN_PAREN91_tree=null; 3960 CommonTree CLOSE_PAREN93_tree=null; 3961 RewriteRuleTokenStream stream_OPEN_PAREN=new RewriteRuleTokenStream(adaptor,"token OPEN_PAREN"); 3962 RewriteRuleTokenStream stream_CLOSE_PAREN=new RewriteRuleTokenStream(adaptor,"token CLOSE_PAREN"); 3963 RewriteRuleSubtreeStream stream_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule type_descriptor"); 3964 RewriteRuleSubtreeStream stream_param_list=new RewriteRuleSubtreeStream(adaptor,"rule param_list"); 3965 3966 try { 3967 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:598:3: ( OPEN_PAREN param_list CLOSE_PAREN type_descriptor -> ^( I_METHOD_PROTOTYPE[$start, \"I_METHOD_PROTOTYPE\"] ^( I_METHOD_RETURN_TYPE type_descriptor ) ( param_list )? ) ) 3968 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:598:5: OPEN_PAREN param_list CLOSE_PAREN type_descriptor 3969 { 3970 OPEN_PAREN91=(Token)match(input,OPEN_PAREN,FOLLOW_OPEN_PAREN_in_method_prototype2308); 3971 stream_OPEN_PAREN.add(OPEN_PAREN91); 3972 3973 pushFollow(FOLLOW_param_list_in_method_prototype2310); 3974 param_list92=param_list(); 3975 state._fsp--; 3976 3977 stream_param_list.add(param_list92.getTree()); 3978 CLOSE_PAREN93=(Token)match(input,CLOSE_PAREN,FOLLOW_CLOSE_PAREN_in_method_prototype2312); 3979 stream_CLOSE_PAREN.add(CLOSE_PAREN93); 3980 3981 pushFollow(FOLLOW_type_descriptor_in_method_prototype2314); 3982 type_descriptor94=type_descriptor(); 3983 state._fsp--; 3984 3985 stream_type_descriptor.add(type_descriptor94.getTree()); 3986 // AST REWRITE 3987 // elements: type_descriptor, param_list 3988 // token labels: 3989 // rule labels: retval 3990 // token list labels: 3991 // rule list labels: 3992 // wildcard labels: 3993 retval.tree = root_0; 3994 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3995 3996 root_0 = (CommonTree)adaptor.nil(); 3997 // 599:5: -> ^( I_METHOD_PROTOTYPE[$start, \"I_METHOD_PROTOTYPE\"] ^( I_METHOD_RETURN_TYPE type_descriptor ) ( param_list )? ) 3998 { 3999 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:599:8: ^( I_METHOD_PROTOTYPE[$start, \"I_METHOD_PROTOTYPE\"] ^( I_METHOD_RETURN_TYPE type_descriptor ) ( param_list )? ) 4000 { 4001 CommonTree root_1 = (CommonTree)adaptor.nil(); 4002 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_METHOD_PROTOTYPE, (retval.start), "I_METHOD_PROTOTYPE"), root_1); 4003 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:599:59: ^( I_METHOD_RETURN_TYPE type_descriptor ) 4004 { 4005 CommonTree root_2 = (CommonTree)adaptor.nil(); 4006 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_METHOD_RETURN_TYPE, "I_METHOD_RETURN_TYPE"), root_2); 4007 adaptor.addChild(root_2, stream_type_descriptor.nextTree()); 4008 adaptor.addChild(root_1, root_2); 4009 } 4010 4011 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:599:99: ( param_list )? 4012 if ( stream_param_list.hasNext() ) { 4013 adaptor.addChild(root_1, stream_param_list.nextTree()); 4014 } 4015 stream_param_list.reset(); 4016 4017 adaptor.addChild(root_0, root_1); 4018 } 4019 4020 } 4021 4022 4023 retval.tree = root_0; 4024 4025 } 4026 4027 retval.stop = input.LT(-1); 4028 4029 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 4030 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 4031 4032 } 4033 catch (RecognitionException re) { 4034 reportError(re); 4035 recover(input,re); 4036 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4037 } 4038 finally { 4039 // do for sure before leaving 4040 } 4041 return retval; 4042 } 4043 // $ANTLR end "method_prototype" 4044 4045 4046 public static class param_list_return extends ParserRuleReturnScope { 4047 CommonTree tree; 4048 @Override getTree()4049 public CommonTree getTree() { return tree; } 4050 }; 4051 4052 4053 // $ANTLR start "param_list" 4054 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:601: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 )* ); param_list()4055 public final smaliParser.param_list_return param_list() throws RecognitionException { 4056 smaliParser.param_list_return retval = new smaliParser.param_list_return(); 4057 retval.start = input.LT(1); 4058 4059 CommonTree root_0 = null; 4060 4061 Token PARAM_LIST_START95=null; 4062 Token PARAM_LIST_END97=null; 4063 Token PARAM_LIST_OR_ID_START98=null; 4064 Token PRIMITIVE_TYPE99=null; 4065 Token PARAM_LIST_OR_ID_END100=null; 4066 ParserRuleReturnScope nonvoid_type_descriptor96 =null; 4067 ParserRuleReturnScope nonvoid_type_descriptor101 =null; 4068 4069 CommonTree PARAM_LIST_START95_tree=null; 4070 CommonTree PARAM_LIST_END97_tree=null; 4071 CommonTree PARAM_LIST_OR_ID_START98_tree=null; 4072 CommonTree PRIMITIVE_TYPE99_tree=null; 4073 CommonTree PARAM_LIST_OR_ID_END100_tree=null; 4074 RewriteRuleTokenStream stream_PARAM_LIST_OR_ID_START=new RewriteRuleTokenStream(adaptor,"token PARAM_LIST_OR_ID_START"); 4075 RewriteRuleTokenStream stream_PARAM_LIST_OR_ID_END=new RewriteRuleTokenStream(adaptor,"token PARAM_LIST_OR_ID_END"); 4076 RewriteRuleTokenStream stream_PARAM_LIST_START=new RewriteRuleTokenStream(adaptor,"token PARAM_LIST_START"); 4077 RewriteRuleTokenStream stream_PARAM_LIST_END=new RewriteRuleTokenStream(adaptor,"token PARAM_LIST_END"); 4078 RewriteRuleTokenStream stream_PRIMITIVE_TYPE=new RewriteRuleTokenStream(adaptor,"token PRIMITIVE_TYPE"); 4079 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 4080 4081 try { 4082 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:602: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 )* ) 4083 int alt15=3; 4084 switch ( input.LA(1) ) { 4085 case PARAM_LIST_START: 4086 { 4087 alt15=1; 4088 } 4089 break; 4090 case PARAM_LIST_OR_ID_START: 4091 { 4092 alt15=2; 4093 } 4094 break; 4095 case ARRAY_DESCRIPTOR: 4096 case CLASS_DESCRIPTOR: 4097 case CLOSE_PAREN: 4098 case PRIMITIVE_TYPE: 4099 { 4100 alt15=3; 4101 } 4102 break; 4103 default: 4104 NoViableAltException nvae = 4105 new NoViableAltException("", 15, 0, input); 4106 throw nvae; 4107 } 4108 switch (alt15) { 4109 case 1 : 4110 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:602:5: PARAM_LIST_START ( nonvoid_type_descriptor )* PARAM_LIST_END 4111 { 4112 PARAM_LIST_START95=(Token)match(input,PARAM_LIST_START,FOLLOW_PARAM_LIST_START_in_param_list2344); 4113 stream_PARAM_LIST_START.add(PARAM_LIST_START95); 4114 4115 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:602:22: ( nonvoid_type_descriptor )* 4116 loop12: 4117 while (true) { 4118 int alt12=2; 4119 int LA12_0 = input.LA(1); 4120 if ( (LA12_0==ARRAY_DESCRIPTOR||LA12_0==CLASS_DESCRIPTOR||LA12_0==PRIMITIVE_TYPE) ) { 4121 alt12=1; 4122 } 4123 4124 switch (alt12) { 4125 case 1 : 4126 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:602:22: nonvoid_type_descriptor 4127 { 4128 pushFollow(FOLLOW_nonvoid_type_descriptor_in_param_list2346); 4129 nonvoid_type_descriptor96=nonvoid_type_descriptor(); 4130 state._fsp--; 4131 4132 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor96.getTree()); 4133 } 4134 break; 4135 4136 default : 4137 break loop12; 4138 } 4139 } 4140 4141 PARAM_LIST_END97=(Token)match(input,PARAM_LIST_END,FOLLOW_PARAM_LIST_END_in_param_list2349); 4142 stream_PARAM_LIST_END.add(PARAM_LIST_END97); 4143 4144 // AST REWRITE 4145 // elements: nonvoid_type_descriptor 4146 // token labels: 4147 // rule labels: retval 4148 // token list labels: 4149 // rule list labels: 4150 // wildcard labels: 4151 retval.tree = root_0; 4152 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 4153 4154 root_0 = (CommonTree)adaptor.nil(); 4155 // 602:62: -> ( nonvoid_type_descriptor )* 4156 { 4157 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:602:65: ( nonvoid_type_descriptor )* 4158 while ( stream_nonvoid_type_descriptor.hasNext() ) { 4159 adaptor.addChild(root_0, stream_nonvoid_type_descriptor.nextTree()); 4160 } 4161 stream_nonvoid_type_descriptor.reset(); 4162 4163 } 4164 4165 4166 retval.tree = root_0; 4167 4168 } 4169 break; 4170 case 2 : 4171 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:603:5: PARAM_LIST_OR_ID_START ( PRIMITIVE_TYPE )* PARAM_LIST_OR_ID_END 4172 { 4173 PARAM_LIST_OR_ID_START98=(Token)match(input,PARAM_LIST_OR_ID_START,FOLLOW_PARAM_LIST_OR_ID_START_in_param_list2360); 4174 stream_PARAM_LIST_OR_ID_START.add(PARAM_LIST_OR_ID_START98); 4175 4176 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:603:28: ( PRIMITIVE_TYPE )* 4177 loop13: 4178 while (true) { 4179 int alt13=2; 4180 int LA13_0 = input.LA(1); 4181 if ( (LA13_0==PRIMITIVE_TYPE) ) { 4182 alt13=1; 4183 } 4184 4185 switch (alt13) { 4186 case 1 : 4187 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:603:28: PRIMITIVE_TYPE 4188 { 4189 PRIMITIVE_TYPE99=(Token)match(input,PRIMITIVE_TYPE,FOLLOW_PRIMITIVE_TYPE_in_param_list2362); 4190 stream_PRIMITIVE_TYPE.add(PRIMITIVE_TYPE99); 4191 4192 } 4193 break; 4194 4195 default : 4196 break loop13; 4197 } 4198 } 4199 4200 PARAM_LIST_OR_ID_END100=(Token)match(input,PARAM_LIST_OR_ID_END,FOLLOW_PARAM_LIST_OR_ID_END_in_param_list2365); 4201 stream_PARAM_LIST_OR_ID_END.add(PARAM_LIST_OR_ID_END100); 4202 4203 // AST REWRITE 4204 // elements: PRIMITIVE_TYPE 4205 // token labels: 4206 // rule labels: retval 4207 // token list labels: 4208 // rule list labels: 4209 // wildcard labels: 4210 retval.tree = root_0; 4211 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 4212 4213 root_0 = (CommonTree)adaptor.nil(); 4214 // 603:65: -> ( PRIMITIVE_TYPE )* 4215 { 4216 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:603:68: ( PRIMITIVE_TYPE )* 4217 while ( stream_PRIMITIVE_TYPE.hasNext() ) { 4218 adaptor.addChild(root_0, stream_PRIMITIVE_TYPE.nextNode()); 4219 } 4220 stream_PRIMITIVE_TYPE.reset(); 4221 4222 } 4223 4224 4225 retval.tree = root_0; 4226 4227 } 4228 break; 4229 case 3 : 4230 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:604:5: ( nonvoid_type_descriptor )* 4231 { 4232 root_0 = (CommonTree)adaptor.nil(); 4233 4234 4235 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:604:5: ( nonvoid_type_descriptor )* 4236 loop14: 4237 while (true) { 4238 int alt14=2; 4239 int LA14_0 = input.LA(1); 4240 if ( (LA14_0==ARRAY_DESCRIPTOR||LA14_0==CLASS_DESCRIPTOR||LA14_0==PRIMITIVE_TYPE) ) { 4241 alt14=1; 4242 } 4243 4244 switch (alt14) { 4245 case 1 : 4246 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:604:5: nonvoid_type_descriptor 4247 { 4248 pushFollow(FOLLOW_nonvoid_type_descriptor_in_param_list2376); 4249 nonvoid_type_descriptor101=nonvoid_type_descriptor(); 4250 state._fsp--; 4251 4252 adaptor.addChild(root_0, nonvoid_type_descriptor101.getTree()); 4253 4254 } 4255 break; 4256 4257 default : 4258 break loop14; 4259 } 4260 } 4261 4262 } 4263 break; 4264 4265 } 4266 retval.stop = input.LT(-1); 4267 4268 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 4269 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 4270 4271 } 4272 catch (RecognitionException re) { 4273 reportError(re); 4274 recover(input,re); 4275 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4276 } 4277 finally { 4278 // do for sure before leaving 4279 } 4280 return retval; 4281 } 4282 // $ANTLR end "param_list" 4283 4284 4285 public static class type_descriptor_return extends ParserRuleReturnScope { 4286 CommonTree tree; 4287 @Override getTree()4288 public CommonTree getTree() { return tree; } 4289 }; 4290 4291 4292 // $ANTLR start "type_descriptor" 4293 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:606:1: type_descriptor : ( VOID_TYPE | PRIMITIVE_TYPE | CLASS_DESCRIPTOR | ARRAY_DESCRIPTOR ); type_descriptor()4294 public final smaliParser.type_descriptor_return type_descriptor() throws RecognitionException { 4295 smaliParser.type_descriptor_return retval = new smaliParser.type_descriptor_return(); 4296 retval.start = input.LT(1); 4297 4298 CommonTree root_0 = null; 4299 4300 Token set102=null; 4301 4302 CommonTree set102_tree=null; 4303 4304 try { 4305 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:607:3: ( VOID_TYPE | PRIMITIVE_TYPE | CLASS_DESCRIPTOR | ARRAY_DESCRIPTOR ) 4306 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g: 4307 { 4308 root_0 = (CommonTree)adaptor.nil(); 4309 4310 4311 set102=input.LT(1); 4312 if ( input.LA(1)==ARRAY_DESCRIPTOR||input.LA(1)==CLASS_DESCRIPTOR||input.LA(1)==PRIMITIVE_TYPE||input.LA(1)==VOID_TYPE ) { 4313 input.consume(); 4314 adaptor.addChild(root_0, (CommonTree)adaptor.create(set102)); 4315 state.errorRecovery=false; 4316 } 4317 else { 4318 MismatchedSetException mse = new MismatchedSetException(null,input); 4319 throw mse; 4320 } 4321 } 4322 4323 retval.stop = input.LT(-1); 4324 4325 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 4326 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 4327 4328 } 4329 catch (RecognitionException re) { 4330 reportError(re); 4331 recover(input,re); 4332 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4333 } 4334 finally { 4335 // do for sure before leaving 4336 } 4337 return retval; 4338 } 4339 // $ANTLR end "type_descriptor" 4340 4341 4342 public static class nonvoid_type_descriptor_return extends ParserRuleReturnScope { 4343 CommonTree tree; 4344 @Override getTree()4345 public CommonTree getTree() { return tree; } 4346 }; 4347 4348 4349 // $ANTLR start "nonvoid_type_descriptor" 4350 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:612:1: nonvoid_type_descriptor : ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR | ARRAY_DESCRIPTOR ); nonvoid_type_descriptor()4351 public final smaliParser.nonvoid_type_descriptor_return nonvoid_type_descriptor() throws RecognitionException { 4352 smaliParser.nonvoid_type_descriptor_return retval = new smaliParser.nonvoid_type_descriptor_return(); 4353 retval.start = input.LT(1); 4354 4355 CommonTree root_0 = null; 4356 4357 Token set103=null; 4358 4359 CommonTree set103_tree=null; 4360 4361 try { 4362 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:613:3: ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR | ARRAY_DESCRIPTOR ) 4363 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g: 4364 { 4365 root_0 = (CommonTree)adaptor.nil(); 4366 4367 4368 set103=input.LT(1); 4369 if ( input.LA(1)==ARRAY_DESCRIPTOR||input.LA(1)==CLASS_DESCRIPTOR||input.LA(1)==PRIMITIVE_TYPE ) { 4370 input.consume(); 4371 adaptor.addChild(root_0, (CommonTree)adaptor.create(set103)); 4372 state.errorRecovery=false; 4373 } 4374 else { 4375 MismatchedSetException mse = new MismatchedSetException(null,input); 4376 throw mse; 4377 } 4378 } 4379 4380 retval.stop = input.LT(-1); 4381 4382 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 4383 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 4384 4385 } 4386 catch (RecognitionException re) { 4387 reportError(re); 4388 recover(input,re); 4389 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4390 } 4391 finally { 4392 // do for sure before leaving 4393 } 4394 return retval; 4395 } 4396 // $ANTLR end "nonvoid_type_descriptor" 4397 4398 4399 public static class reference_type_descriptor_return extends ParserRuleReturnScope { 4400 CommonTree tree; 4401 @Override getTree()4402 public CommonTree getTree() { return tree; } 4403 }; 4404 4405 4406 // $ANTLR start "reference_type_descriptor" 4407 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:617:1: reference_type_descriptor : ( CLASS_DESCRIPTOR | ARRAY_DESCRIPTOR ); reference_type_descriptor()4408 public final smaliParser.reference_type_descriptor_return reference_type_descriptor() throws RecognitionException { 4409 smaliParser.reference_type_descriptor_return retval = new smaliParser.reference_type_descriptor_return(); 4410 retval.start = input.LT(1); 4411 4412 CommonTree root_0 = null; 4413 4414 Token set104=null; 4415 4416 CommonTree set104_tree=null; 4417 4418 try { 4419 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:618:3: ( CLASS_DESCRIPTOR | ARRAY_DESCRIPTOR ) 4420 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g: 4421 { 4422 root_0 = (CommonTree)adaptor.nil(); 4423 4424 4425 set104=input.LT(1); 4426 if ( input.LA(1)==ARRAY_DESCRIPTOR||input.LA(1)==CLASS_DESCRIPTOR ) { 4427 input.consume(); 4428 adaptor.addChild(root_0, (CommonTree)adaptor.create(set104)); 4429 state.errorRecovery=false; 4430 } 4431 else { 4432 MismatchedSetException mse = new MismatchedSetException(null,input); 4433 throw mse; 4434 } 4435 } 4436 4437 retval.stop = input.LT(-1); 4438 4439 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 4440 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 4441 4442 } 4443 catch (RecognitionException re) { 4444 reportError(re); 4445 recover(input,re); 4446 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4447 } 4448 finally { 4449 // do for sure before leaving 4450 } 4451 return retval; 4452 } 4453 // $ANTLR end "reference_type_descriptor" 4454 4455 4456 public static class integer_literal_return extends ParserRuleReturnScope { 4457 CommonTree tree; 4458 @Override getTree()4459 public CommonTree getTree() { return tree; } 4460 }; 4461 4462 4463 // $ANTLR start "integer_literal" 4464 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:621:1: integer_literal : ( POSITIVE_INTEGER_LITERAL -> INTEGER_LITERAL[$POSITIVE_INTEGER_LITERAL] | NEGATIVE_INTEGER_LITERAL -> INTEGER_LITERAL[$NEGATIVE_INTEGER_LITERAL] ); integer_literal()4465 public final smaliParser.integer_literal_return integer_literal() throws RecognitionException { 4466 smaliParser.integer_literal_return retval = new smaliParser.integer_literal_return(); 4467 retval.start = input.LT(1); 4468 4469 CommonTree root_0 = null; 4470 4471 Token POSITIVE_INTEGER_LITERAL105=null; 4472 Token NEGATIVE_INTEGER_LITERAL106=null; 4473 4474 CommonTree POSITIVE_INTEGER_LITERAL105_tree=null; 4475 CommonTree NEGATIVE_INTEGER_LITERAL106_tree=null; 4476 RewriteRuleTokenStream stream_NEGATIVE_INTEGER_LITERAL=new RewriteRuleTokenStream(adaptor,"token NEGATIVE_INTEGER_LITERAL"); 4477 RewriteRuleTokenStream stream_POSITIVE_INTEGER_LITERAL=new RewriteRuleTokenStream(adaptor,"token POSITIVE_INTEGER_LITERAL"); 4478 4479 try { 4480 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:622:3: ( POSITIVE_INTEGER_LITERAL -> INTEGER_LITERAL[$POSITIVE_INTEGER_LITERAL] | NEGATIVE_INTEGER_LITERAL -> INTEGER_LITERAL[$NEGATIVE_INTEGER_LITERAL] ) 4481 int alt16=2; 4482 int LA16_0 = input.LA(1); 4483 if ( (LA16_0==POSITIVE_INTEGER_LITERAL) ) { 4484 alt16=1; 4485 } 4486 else if ( (LA16_0==NEGATIVE_INTEGER_LITERAL) ) { 4487 alt16=2; 4488 } 4489 4490 else { 4491 NoViableAltException nvae = 4492 new NoViableAltException("", 16, 0, input); 4493 throw nvae; 4494 } 4495 4496 switch (alt16) { 4497 case 1 : 4498 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:622:5: POSITIVE_INTEGER_LITERAL 4499 { 4500 POSITIVE_INTEGER_LITERAL105=(Token)match(input,POSITIVE_INTEGER_LITERAL,FOLLOW_POSITIVE_INTEGER_LITERAL_in_integer_literal2453); 4501 stream_POSITIVE_INTEGER_LITERAL.add(POSITIVE_INTEGER_LITERAL105); 4502 4503 // AST REWRITE 4504 // elements: 4505 // token labels: 4506 // rule labels: retval 4507 // token list labels: 4508 // rule list labels: 4509 // wildcard labels: 4510 retval.tree = root_0; 4511 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 4512 4513 root_0 = (CommonTree)adaptor.nil(); 4514 // 622:30: -> INTEGER_LITERAL[$POSITIVE_INTEGER_LITERAL] 4515 { 4516 adaptor.addChild(root_0, (CommonTree)adaptor.create(INTEGER_LITERAL, POSITIVE_INTEGER_LITERAL105)); 4517 } 4518 4519 4520 retval.tree = root_0; 4521 4522 } 4523 break; 4524 case 2 : 4525 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:623:5: NEGATIVE_INTEGER_LITERAL 4526 { 4527 NEGATIVE_INTEGER_LITERAL106=(Token)match(input,NEGATIVE_INTEGER_LITERAL,FOLLOW_NEGATIVE_INTEGER_LITERAL_in_integer_literal2464); 4528 stream_NEGATIVE_INTEGER_LITERAL.add(NEGATIVE_INTEGER_LITERAL106); 4529 4530 // AST REWRITE 4531 // elements: 4532 // token labels: 4533 // rule labels: retval 4534 // token list labels: 4535 // rule list labels: 4536 // wildcard labels: 4537 retval.tree = root_0; 4538 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 4539 4540 root_0 = (CommonTree)adaptor.nil(); 4541 // 623:30: -> INTEGER_LITERAL[$NEGATIVE_INTEGER_LITERAL] 4542 { 4543 adaptor.addChild(root_0, (CommonTree)adaptor.create(INTEGER_LITERAL, NEGATIVE_INTEGER_LITERAL106)); 4544 } 4545 4546 4547 retval.tree = root_0; 4548 4549 } 4550 break; 4551 4552 } 4553 retval.stop = input.LT(-1); 4554 4555 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 4556 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 4557 4558 } 4559 catch (RecognitionException re) { 4560 reportError(re); 4561 recover(input,re); 4562 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4563 } 4564 finally { 4565 // do for sure before leaving 4566 } 4567 return retval; 4568 } 4569 // $ANTLR end "integer_literal" 4570 4571 4572 public static class float_literal_return extends ParserRuleReturnScope { 4573 CommonTree tree; 4574 @Override getTree()4575 public CommonTree getTree() { return tree; } 4576 }; 4577 4578 4579 // $ANTLR start "float_literal" 4580 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:625:1: float_literal : ( FLOAT_LITERAL_OR_ID -> FLOAT_LITERAL[$FLOAT_LITERAL_OR_ID] | FLOAT_LITERAL ); float_literal()4581 public final smaliParser.float_literal_return float_literal() throws RecognitionException { 4582 smaliParser.float_literal_return retval = new smaliParser.float_literal_return(); 4583 retval.start = input.LT(1); 4584 4585 CommonTree root_0 = null; 4586 4587 Token FLOAT_LITERAL_OR_ID107=null; 4588 Token FLOAT_LITERAL108=null; 4589 4590 CommonTree FLOAT_LITERAL_OR_ID107_tree=null; 4591 CommonTree FLOAT_LITERAL108_tree=null; 4592 RewriteRuleTokenStream stream_FLOAT_LITERAL_OR_ID=new RewriteRuleTokenStream(adaptor,"token FLOAT_LITERAL_OR_ID"); 4593 4594 try { 4595 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:626:3: ( FLOAT_LITERAL_OR_ID -> FLOAT_LITERAL[$FLOAT_LITERAL_OR_ID] | FLOAT_LITERAL ) 4596 int alt17=2; 4597 int LA17_0 = input.LA(1); 4598 if ( (LA17_0==FLOAT_LITERAL_OR_ID) ) { 4599 alt17=1; 4600 } 4601 else if ( (LA17_0==FLOAT_LITERAL) ) { 4602 alt17=2; 4603 } 4604 4605 else { 4606 NoViableAltException nvae = 4607 new NoViableAltException("", 17, 0, input); 4608 throw nvae; 4609 } 4610 4611 switch (alt17) { 4612 case 1 : 4613 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:626:5: FLOAT_LITERAL_OR_ID 4614 { 4615 FLOAT_LITERAL_OR_ID107=(Token)match(input,FLOAT_LITERAL_OR_ID,FOLLOW_FLOAT_LITERAL_OR_ID_in_float_literal2479); 4616 stream_FLOAT_LITERAL_OR_ID.add(FLOAT_LITERAL_OR_ID107); 4617 4618 // AST REWRITE 4619 // elements: 4620 // token labels: 4621 // rule labels: retval 4622 // token list labels: 4623 // rule list labels: 4624 // wildcard labels: 4625 retval.tree = root_0; 4626 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 4627 4628 root_0 = (CommonTree)adaptor.nil(); 4629 // 626:25: -> FLOAT_LITERAL[$FLOAT_LITERAL_OR_ID] 4630 { 4631 adaptor.addChild(root_0, (CommonTree)adaptor.create(FLOAT_LITERAL, FLOAT_LITERAL_OR_ID107)); 4632 } 4633 4634 4635 retval.tree = root_0; 4636 4637 } 4638 break; 4639 case 2 : 4640 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:627:5: FLOAT_LITERAL 4641 { 4642 root_0 = (CommonTree)adaptor.nil(); 4643 4644 4645 FLOAT_LITERAL108=(Token)match(input,FLOAT_LITERAL,FOLLOW_FLOAT_LITERAL_in_float_literal2490); 4646 FLOAT_LITERAL108_tree = (CommonTree)adaptor.create(FLOAT_LITERAL108); 4647 adaptor.addChild(root_0, FLOAT_LITERAL108_tree); 4648 4649 } 4650 break; 4651 4652 } 4653 retval.stop = input.LT(-1); 4654 4655 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 4656 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 4657 4658 } 4659 catch (RecognitionException re) { 4660 reportError(re); 4661 recover(input,re); 4662 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4663 } 4664 finally { 4665 // do for sure before leaving 4666 } 4667 return retval; 4668 } 4669 // $ANTLR end "float_literal" 4670 4671 4672 public static class double_literal_return extends ParserRuleReturnScope { 4673 CommonTree tree; 4674 @Override getTree()4675 public CommonTree getTree() { return tree; } 4676 }; 4677 4678 4679 // $ANTLR start "double_literal" 4680 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:629:1: double_literal : ( DOUBLE_LITERAL_OR_ID -> DOUBLE_LITERAL[$DOUBLE_LITERAL_OR_ID] | DOUBLE_LITERAL ); double_literal()4681 public final smaliParser.double_literal_return double_literal() throws RecognitionException { 4682 smaliParser.double_literal_return retval = new smaliParser.double_literal_return(); 4683 retval.start = input.LT(1); 4684 4685 CommonTree root_0 = null; 4686 4687 Token DOUBLE_LITERAL_OR_ID109=null; 4688 Token DOUBLE_LITERAL110=null; 4689 4690 CommonTree DOUBLE_LITERAL_OR_ID109_tree=null; 4691 CommonTree DOUBLE_LITERAL110_tree=null; 4692 RewriteRuleTokenStream stream_DOUBLE_LITERAL_OR_ID=new RewriteRuleTokenStream(adaptor,"token DOUBLE_LITERAL_OR_ID"); 4693 4694 try { 4695 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:630:3: ( DOUBLE_LITERAL_OR_ID -> DOUBLE_LITERAL[$DOUBLE_LITERAL_OR_ID] | DOUBLE_LITERAL ) 4696 int alt18=2; 4697 int LA18_0 = input.LA(1); 4698 if ( (LA18_0==DOUBLE_LITERAL_OR_ID) ) { 4699 alt18=1; 4700 } 4701 else if ( (LA18_0==DOUBLE_LITERAL) ) { 4702 alt18=2; 4703 } 4704 4705 else { 4706 NoViableAltException nvae = 4707 new NoViableAltException("", 18, 0, input); 4708 throw nvae; 4709 } 4710 4711 switch (alt18) { 4712 case 1 : 4713 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:630:5: DOUBLE_LITERAL_OR_ID 4714 { 4715 DOUBLE_LITERAL_OR_ID109=(Token)match(input,DOUBLE_LITERAL_OR_ID,FOLLOW_DOUBLE_LITERAL_OR_ID_in_double_literal2500); 4716 stream_DOUBLE_LITERAL_OR_ID.add(DOUBLE_LITERAL_OR_ID109); 4717 4718 // AST REWRITE 4719 // elements: 4720 // token labels: 4721 // rule labels: retval 4722 // token list labels: 4723 // rule list labels: 4724 // wildcard labels: 4725 retval.tree = root_0; 4726 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 4727 4728 root_0 = (CommonTree)adaptor.nil(); 4729 // 630:26: -> DOUBLE_LITERAL[$DOUBLE_LITERAL_OR_ID] 4730 { 4731 adaptor.addChild(root_0, (CommonTree)adaptor.create(DOUBLE_LITERAL, DOUBLE_LITERAL_OR_ID109)); 4732 } 4733 4734 4735 retval.tree = root_0; 4736 4737 } 4738 break; 4739 case 2 : 4740 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:631:5: DOUBLE_LITERAL 4741 { 4742 root_0 = (CommonTree)adaptor.nil(); 4743 4744 4745 DOUBLE_LITERAL110=(Token)match(input,DOUBLE_LITERAL,FOLLOW_DOUBLE_LITERAL_in_double_literal2511); 4746 DOUBLE_LITERAL110_tree = (CommonTree)adaptor.create(DOUBLE_LITERAL110); 4747 adaptor.addChild(root_0, DOUBLE_LITERAL110_tree); 4748 4749 } 4750 break; 4751 4752 } 4753 retval.stop = input.LT(-1); 4754 4755 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 4756 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 4757 4758 } 4759 catch (RecognitionException re) { 4760 reportError(re); 4761 recover(input,re); 4762 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4763 } 4764 finally { 4765 // do for sure before leaving 4766 } 4767 return retval; 4768 } 4769 // $ANTLR end "double_literal" 4770 4771 4772 public static class literal_return extends ParserRuleReturnScope { 4773 CommonTree tree; 4774 @Override getTree()4775 public CommonTree getTree() { return tree; } 4776 }; 4777 4778 4779 // $ANTLR start "literal" 4780 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:633: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 ); literal()4781 public final smaliParser.literal_return literal() throws RecognitionException { 4782 smaliParser.literal_return retval = new smaliParser.literal_return(); 4783 retval.start = input.LT(1); 4784 4785 CommonTree root_0 = null; 4786 4787 Token LONG_LITERAL111=null; 4788 Token SHORT_LITERAL113=null; 4789 Token BYTE_LITERAL114=null; 4790 Token CHAR_LITERAL117=null; 4791 Token STRING_LITERAL118=null; 4792 Token BOOL_LITERAL119=null; 4793 Token NULL_LITERAL120=null; 4794 ParserRuleReturnScope integer_literal112 =null; 4795 ParserRuleReturnScope float_literal115 =null; 4796 ParserRuleReturnScope double_literal116 =null; 4797 ParserRuleReturnScope array_literal121 =null; 4798 ParserRuleReturnScope subannotation122 =null; 4799 ParserRuleReturnScope type_field_method_literal123 =null; 4800 ParserRuleReturnScope enum_literal124 =null; 4801 4802 CommonTree LONG_LITERAL111_tree=null; 4803 CommonTree SHORT_LITERAL113_tree=null; 4804 CommonTree BYTE_LITERAL114_tree=null; 4805 CommonTree CHAR_LITERAL117_tree=null; 4806 CommonTree STRING_LITERAL118_tree=null; 4807 CommonTree BOOL_LITERAL119_tree=null; 4808 CommonTree NULL_LITERAL120_tree=null; 4809 4810 try { 4811 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:634: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 ) 4812 int alt19=14; 4813 switch ( input.LA(1) ) { 4814 case LONG_LITERAL: 4815 { 4816 alt19=1; 4817 } 4818 break; 4819 case POSITIVE_INTEGER_LITERAL: 4820 { 4821 int LA19_2 = input.LA(2); 4822 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_FORMAT25x)||(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)) ) { 4823 alt19=2; 4824 } 4825 else if ( (LA19_2==COLON||LA19_2==OPEN_PAREN) ) { 4826 alt19=13; 4827 } 4828 4829 else { 4830 int nvaeMark = input.mark(); 4831 try { 4832 input.consume(); 4833 NoViableAltException nvae = 4834 new NoViableAltException("", 19, 2, input); 4835 throw nvae; 4836 } finally { 4837 input.rewind(nvaeMark); 4838 } 4839 } 4840 4841 } 4842 break; 4843 case NEGATIVE_INTEGER_LITERAL: 4844 { 4845 int LA19_3 = input.LA(2); 4846 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_FORMAT25x)||(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)) ) { 4847 alt19=2; 4848 } 4849 else if ( (LA19_3==COLON||LA19_3==OPEN_PAREN) ) { 4850 alt19=13; 4851 } 4852 4853 else { 4854 int nvaeMark = input.mark(); 4855 try { 4856 input.consume(); 4857 NoViableAltException nvae = 4858 new NoViableAltException("", 19, 3, input); 4859 throw nvae; 4860 } finally { 4861 input.rewind(nvaeMark); 4862 } 4863 } 4864 4865 } 4866 break; 4867 case SHORT_LITERAL: 4868 { 4869 alt19=3; 4870 } 4871 break; 4872 case BYTE_LITERAL: 4873 { 4874 alt19=4; 4875 } 4876 break; 4877 case FLOAT_LITERAL_OR_ID: 4878 { 4879 int LA19_6 = input.LA(2); 4880 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_FORMAT25x)||(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)) ) { 4881 alt19=5; 4882 } 4883 else if ( (LA19_6==COLON||LA19_6==OPEN_PAREN) ) { 4884 alt19=13; 4885 } 4886 4887 else { 4888 int nvaeMark = input.mark(); 4889 try { 4890 input.consume(); 4891 NoViableAltException nvae = 4892 new NoViableAltException("", 19, 6, input); 4893 throw nvae; 4894 } finally { 4895 input.rewind(nvaeMark); 4896 } 4897 } 4898 4899 } 4900 break; 4901 case FLOAT_LITERAL: 4902 { 4903 alt19=5; 4904 } 4905 break; 4906 case DOUBLE_LITERAL_OR_ID: 4907 { 4908 int LA19_8 = input.LA(2); 4909 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_FORMAT25x)||(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)) ) { 4910 alt19=6; 4911 } 4912 else if ( (LA19_8==COLON||LA19_8==OPEN_PAREN) ) { 4913 alt19=13; 4914 } 4915 4916 else { 4917 int nvaeMark = input.mark(); 4918 try { 4919 input.consume(); 4920 NoViableAltException nvae = 4921 new NoViableAltException("", 19, 8, input); 4922 throw nvae; 4923 } finally { 4924 input.rewind(nvaeMark); 4925 } 4926 } 4927 4928 } 4929 break; 4930 case DOUBLE_LITERAL: 4931 { 4932 alt19=6; 4933 } 4934 break; 4935 case CHAR_LITERAL: 4936 { 4937 alt19=7; 4938 } 4939 break; 4940 case STRING_LITERAL: 4941 { 4942 alt19=8; 4943 } 4944 break; 4945 case BOOL_LITERAL: 4946 { 4947 int LA19_12 = input.LA(2); 4948 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_FORMAT25x)||(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)) ) { 4949 alt19=9; 4950 } 4951 else if ( (LA19_12==COLON||LA19_12==OPEN_PAREN) ) { 4952 alt19=13; 4953 } 4954 4955 else { 4956 int nvaeMark = input.mark(); 4957 try { 4958 input.consume(); 4959 NoViableAltException nvae = 4960 new NoViableAltException("", 19, 12, input); 4961 throw nvae; 4962 } finally { 4963 input.rewind(nvaeMark); 4964 } 4965 } 4966 4967 } 4968 break; 4969 case NULL_LITERAL: 4970 { 4971 int LA19_13 = input.LA(2); 4972 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_FORMAT25x)||(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)) ) { 4973 alt19=10; 4974 } 4975 else if ( (LA19_13==COLON||LA19_13==OPEN_PAREN) ) { 4976 alt19=13; 4977 } 4978 4979 else { 4980 int nvaeMark = input.mark(); 4981 try { 4982 input.consume(); 4983 NoViableAltException nvae = 4984 new NoViableAltException("", 19, 13, input); 4985 throw nvae; 4986 } finally { 4987 input.rewind(nvaeMark); 4988 } 4989 } 4990 4991 } 4992 break; 4993 case OPEN_BRACE: 4994 { 4995 alt19=11; 4996 } 4997 break; 4998 case SUBANNOTATION_DIRECTIVE: 4999 { 5000 alt19=12; 5001 } 5002 break; 5003 case ACCESS_SPEC: 5004 case ANNOTATION_VISIBILITY: 5005 case ARRAY_DESCRIPTOR: 5006 case CLASS_DESCRIPTOR: 5007 case INSTRUCTION_FORMAT10t: 5008 case INSTRUCTION_FORMAT10x: 5009 case INSTRUCTION_FORMAT10x_ODEX: 5010 case INSTRUCTION_FORMAT11x: 5011 case INSTRUCTION_FORMAT12x_OR_ID: 5012 case INSTRUCTION_FORMAT21c_FIELD: 5013 case INSTRUCTION_FORMAT21c_FIELD_ODEX: 5014 case INSTRUCTION_FORMAT21c_LAMBDA: 5015 case INSTRUCTION_FORMAT21c_METHOD: 5016 case INSTRUCTION_FORMAT21c_STRING: 5017 case INSTRUCTION_FORMAT21c_TYPE: 5018 case INSTRUCTION_FORMAT21t: 5019 case INSTRUCTION_FORMAT22c_FIELD: 5020 case INSTRUCTION_FORMAT22c_FIELD_ODEX: 5021 case INSTRUCTION_FORMAT22c_STRING: 5022 case INSTRUCTION_FORMAT22c_TYPE: 5023 case INSTRUCTION_FORMAT22cs_FIELD: 5024 case INSTRUCTION_FORMAT22s_OR_ID: 5025 case INSTRUCTION_FORMAT22t: 5026 case INSTRUCTION_FORMAT23x: 5027 case INSTRUCTION_FORMAT25x: 5028 case INSTRUCTION_FORMAT31i_OR_ID: 5029 case INSTRUCTION_FORMAT31t: 5030 case INSTRUCTION_FORMAT35c_METHOD: 5031 case INSTRUCTION_FORMAT35c_METHOD_ODEX: 5032 case INSTRUCTION_FORMAT35c_TYPE: 5033 case INSTRUCTION_FORMAT35mi_METHOD: 5034 case INSTRUCTION_FORMAT35ms_METHOD: 5035 case INSTRUCTION_FORMAT51l: 5036 case MEMBER_NAME: 5037 case PARAM_LIST_OR_ID_START: 5038 case PRIMITIVE_TYPE: 5039 case REGISTER: 5040 case SIMPLE_NAME: 5041 case VERIFICATION_ERROR_TYPE: 5042 case VOID_TYPE: 5043 { 5044 alt19=13; 5045 } 5046 break; 5047 case ENUM_DIRECTIVE: 5048 { 5049 alt19=14; 5050 } 5051 break; 5052 default: 5053 NoViableAltException nvae = 5054 new NoViableAltException("", 19, 0, input); 5055 throw nvae; 5056 } 5057 switch (alt19) { 5058 case 1 : 5059 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:634:5: LONG_LITERAL 5060 { 5061 root_0 = (CommonTree)adaptor.nil(); 5062 5063 5064 LONG_LITERAL111=(Token)match(input,LONG_LITERAL,FOLLOW_LONG_LITERAL_in_literal2521); 5065 LONG_LITERAL111_tree = (CommonTree)adaptor.create(LONG_LITERAL111); 5066 adaptor.addChild(root_0, LONG_LITERAL111_tree); 5067 5068 } 5069 break; 5070 case 2 : 5071 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:635:5: integer_literal 5072 { 5073 root_0 = (CommonTree)adaptor.nil(); 5074 5075 5076 pushFollow(FOLLOW_integer_literal_in_literal2527); 5077 integer_literal112=integer_literal(); 5078 state._fsp--; 5079 5080 adaptor.addChild(root_0, integer_literal112.getTree()); 5081 5082 } 5083 break; 5084 case 3 : 5085 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:636:5: SHORT_LITERAL 5086 { 5087 root_0 = (CommonTree)adaptor.nil(); 5088 5089 5090 SHORT_LITERAL113=(Token)match(input,SHORT_LITERAL,FOLLOW_SHORT_LITERAL_in_literal2533); 5091 SHORT_LITERAL113_tree = (CommonTree)adaptor.create(SHORT_LITERAL113); 5092 adaptor.addChild(root_0, SHORT_LITERAL113_tree); 5093 5094 } 5095 break; 5096 case 4 : 5097 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:637:5: BYTE_LITERAL 5098 { 5099 root_0 = (CommonTree)adaptor.nil(); 5100 5101 5102 BYTE_LITERAL114=(Token)match(input,BYTE_LITERAL,FOLLOW_BYTE_LITERAL_in_literal2539); 5103 BYTE_LITERAL114_tree = (CommonTree)adaptor.create(BYTE_LITERAL114); 5104 adaptor.addChild(root_0, BYTE_LITERAL114_tree); 5105 5106 } 5107 break; 5108 case 5 : 5109 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:638:5: float_literal 5110 { 5111 root_0 = (CommonTree)adaptor.nil(); 5112 5113 5114 pushFollow(FOLLOW_float_literal_in_literal2545); 5115 float_literal115=float_literal(); 5116 state._fsp--; 5117 5118 adaptor.addChild(root_0, float_literal115.getTree()); 5119 5120 } 5121 break; 5122 case 6 : 5123 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:639:5: double_literal 5124 { 5125 root_0 = (CommonTree)adaptor.nil(); 5126 5127 5128 pushFollow(FOLLOW_double_literal_in_literal2551); 5129 double_literal116=double_literal(); 5130 state._fsp--; 5131 5132 adaptor.addChild(root_0, double_literal116.getTree()); 5133 5134 } 5135 break; 5136 case 7 : 5137 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:640:5: CHAR_LITERAL 5138 { 5139 root_0 = (CommonTree)adaptor.nil(); 5140 5141 5142 CHAR_LITERAL117=(Token)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_literal2557); 5143 CHAR_LITERAL117_tree = (CommonTree)adaptor.create(CHAR_LITERAL117); 5144 adaptor.addChild(root_0, CHAR_LITERAL117_tree); 5145 5146 } 5147 break; 5148 case 8 : 5149 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:641:5: STRING_LITERAL 5150 { 5151 root_0 = (CommonTree)adaptor.nil(); 5152 5153 5154 STRING_LITERAL118=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_literal2563); 5155 STRING_LITERAL118_tree = (CommonTree)adaptor.create(STRING_LITERAL118); 5156 adaptor.addChild(root_0, STRING_LITERAL118_tree); 5157 5158 } 5159 break; 5160 case 9 : 5161 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:642:5: BOOL_LITERAL 5162 { 5163 root_0 = (CommonTree)adaptor.nil(); 5164 5165 5166 BOOL_LITERAL119=(Token)match(input,BOOL_LITERAL,FOLLOW_BOOL_LITERAL_in_literal2569); 5167 BOOL_LITERAL119_tree = (CommonTree)adaptor.create(BOOL_LITERAL119); 5168 adaptor.addChild(root_0, BOOL_LITERAL119_tree); 5169 5170 } 5171 break; 5172 case 10 : 5173 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:643:5: NULL_LITERAL 5174 { 5175 root_0 = (CommonTree)adaptor.nil(); 5176 5177 5178 NULL_LITERAL120=(Token)match(input,NULL_LITERAL,FOLLOW_NULL_LITERAL_in_literal2575); 5179 NULL_LITERAL120_tree = (CommonTree)adaptor.create(NULL_LITERAL120); 5180 adaptor.addChild(root_0, NULL_LITERAL120_tree); 5181 5182 } 5183 break; 5184 case 11 : 5185 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:644:5: array_literal 5186 { 5187 root_0 = (CommonTree)adaptor.nil(); 5188 5189 5190 pushFollow(FOLLOW_array_literal_in_literal2581); 5191 array_literal121=array_literal(); 5192 state._fsp--; 5193 5194 adaptor.addChild(root_0, array_literal121.getTree()); 5195 5196 } 5197 break; 5198 case 12 : 5199 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:645:5: subannotation 5200 { 5201 root_0 = (CommonTree)adaptor.nil(); 5202 5203 5204 pushFollow(FOLLOW_subannotation_in_literal2587); 5205 subannotation122=subannotation(); 5206 state._fsp--; 5207 5208 adaptor.addChild(root_0, subannotation122.getTree()); 5209 5210 } 5211 break; 5212 case 13 : 5213 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:646:5: type_field_method_literal 5214 { 5215 root_0 = (CommonTree)adaptor.nil(); 5216 5217 5218 pushFollow(FOLLOW_type_field_method_literal_in_literal2593); 5219 type_field_method_literal123=type_field_method_literal(); 5220 state._fsp--; 5221 5222 adaptor.addChild(root_0, type_field_method_literal123.getTree()); 5223 5224 } 5225 break; 5226 case 14 : 5227 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:647:5: enum_literal 5228 { 5229 root_0 = (CommonTree)adaptor.nil(); 5230 5231 5232 pushFollow(FOLLOW_enum_literal_in_literal2599); 5233 enum_literal124=enum_literal(); 5234 state._fsp--; 5235 5236 adaptor.addChild(root_0, enum_literal124.getTree()); 5237 5238 } 5239 break; 5240 5241 } 5242 retval.stop = input.LT(-1); 5243 5244 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 5245 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 5246 5247 } 5248 catch (RecognitionException re) { 5249 reportError(re); 5250 recover(input,re); 5251 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 5252 } 5253 finally { 5254 // do for sure before leaving 5255 } 5256 return retval; 5257 } 5258 // $ANTLR end "literal" 5259 5260 5261 public static class parsed_integer_literal_return extends ParserRuleReturnScope { 5262 public int value; 5263 CommonTree tree; 5264 @Override getTree()5265 public CommonTree getTree() { return tree; } 5266 }; 5267 5268 5269 // $ANTLR start "parsed_integer_literal" 5270 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:649:1: parsed_integer_literal returns [int value] : integer_literal ; parsed_integer_literal()5271 public final smaliParser.parsed_integer_literal_return parsed_integer_literal() throws RecognitionException { 5272 smaliParser.parsed_integer_literal_return retval = new smaliParser.parsed_integer_literal_return(); 5273 retval.start = input.LT(1); 5274 5275 CommonTree root_0 = null; 5276 5277 ParserRuleReturnScope integer_literal125 =null; 5278 5279 5280 try { 5281 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:650:3: ( integer_literal ) 5282 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:650:5: integer_literal 5283 { 5284 root_0 = (CommonTree)adaptor.nil(); 5285 5286 5287 pushFollow(FOLLOW_integer_literal_in_parsed_integer_literal2612); 5288 integer_literal125=integer_literal(); 5289 state._fsp--; 5290 5291 adaptor.addChild(root_0, integer_literal125.getTree()); 5292 5293 retval.value = LiteralTools.parseInt((integer_literal125!=null?input.toString(integer_literal125.start,integer_literal125.stop):null)); 5294 } 5295 5296 retval.stop = input.LT(-1); 5297 5298 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 5299 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 5300 5301 } 5302 catch (RecognitionException re) { 5303 reportError(re); 5304 recover(input,re); 5305 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 5306 } 5307 finally { 5308 // do for sure before leaving 5309 } 5310 return retval; 5311 } 5312 // $ANTLR end "parsed_integer_literal" 5313 5314 5315 public static class integral_literal_return extends ParserRuleReturnScope { 5316 CommonTree tree; 5317 @Override getTree()5318 public CommonTree getTree() { return tree; } 5319 }; 5320 5321 5322 // $ANTLR start "integral_literal" 5323 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:652:1: integral_literal : ( LONG_LITERAL | integer_literal | SHORT_LITERAL | CHAR_LITERAL | BYTE_LITERAL ); integral_literal()5324 public final smaliParser.integral_literal_return integral_literal() throws RecognitionException { 5325 smaliParser.integral_literal_return retval = new smaliParser.integral_literal_return(); 5326 retval.start = input.LT(1); 5327 5328 CommonTree root_0 = null; 5329 5330 Token LONG_LITERAL126=null; 5331 Token SHORT_LITERAL128=null; 5332 Token CHAR_LITERAL129=null; 5333 Token BYTE_LITERAL130=null; 5334 ParserRuleReturnScope integer_literal127 =null; 5335 5336 CommonTree LONG_LITERAL126_tree=null; 5337 CommonTree SHORT_LITERAL128_tree=null; 5338 CommonTree CHAR_LITERAL129_tree=null; 5339 CommonTree BYTE_LITERAL130_tree=null; 5340 5341 try { 5342 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:653:3: ( LONG_LITERAL | integer_literal | SHORT_LITERAL | CHAR_LITERAL | BYTE_LITERAL ) 5343 int alt20=5; 5344 switch ( input.LA(1) ) { 5345 case LONG_LITERAL: 5346 { 5347 alt20=1; 5348 } 5349 break; 5350 case NEGATIVE_INTEGER_LITERAL: 5351 case POSITIVE_INTEGER_LITERAL: 5352 { 5353 alt20=2; 5354 } 5355 break; 5356 case SHORT_LITERAL: 5357 { 5358 alt20=3; 5359 } 5360 break; 5361 case CHAR_LITERAL: 5362 { 5363 alt20=4; 5364 } 5365 break; 5366 case BYTE_LITERAL: 5367 { 5368 alt20=5; 5369 } 5370 break; 5371 default: 5372 NoViableAltException nvae = 5373 new NoViableAltException("", 20, 0, input); 5374 throw nvae; 5375 } 5376 switch (alt20) { 5377 case 1 : 5378 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:653:5: LONG_LITERAL 5379 { 5380 root_0 = (CommonTree)adaptor.nil(); 5381 5382 5383 LONG_LITERAL126=(Token)match(input,LONG_LITERAL,FOLLOW_LONG_LITERAL_in_integral_literal2624); 5384 LONG_LITERAL126_tree = (CommonTree)adaptor.create(LONG_LITERAL126); 5385 adaptor.addChild(root_0, LONG_LITERAL126_tree); 5386 5387 } 5388 break; 5389 case 2 : 5390 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:654:5: integer_literal 5391 { 5392 root_0 = (CommonTree)adaptor.nil(); 5393 5394 5395 pushFollow(FOLLOW_integer_literal_in_integral_literal2630); 5396 integer_literal127=integer_literal(); 5397 state._fsp--; 5398 5399 adaptor.addChild(root_0, integer_literal127.getTree()); 5400 5401 } 5402 break; 5403 case 3 : 5404 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:655:5: SHORT_LITERAL 5405 { 5406 root_0 = (CommonTree)adaptor.nil(); 5407 5408 5409 SHORT_LITERAL128=(Token)match(input,SHORT_LITERAL,FOLLOW_SHORT_LITERAL_in_integral_literal2636); 5410 SHORT_LITERAL128_tree = (CommonTree)adaptor.create(SHORT_LITERAL128); 5411 adaptor.addChild(root_0, SHORT_LITERAL128_tree); 5412 5413 } 5414 break; 5415 case 4 : 5416 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:656:5: CHAR_LITERAL 5417 { 5418 root_0 = (CommonTree)adaptor.nil(); 5419 5420 5421 CHAR_LITERAL129=(Token)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_integral_literal2642); 5422 CHAR_LITERAL129_tree = (CommonTree)adaptor.create(CHAR_LITERAL129); 5423 adaptor.addChild(root_0, CHAR_LITERAL129_tree); 5424 5425 } 5426 break; 5427 case 5 : 5428 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:657:5: BYTE_LITERAL 5429 { 5430 root_0 = (CommonTree)adaptor.nil(); 5431 5432 5433 BYTE_LITERAL130=(Token)match(input,BYTE_LITERAL,FOLLOW_BYTE_LITERAL_in_integral_literal2648); 5434 BYTE_LITERAL130_tree = (CommonTree)adaptor.create(BYTE_LITERAL130); 5435 adaptor.addChild(root_0, BYTE_LITERAL130_tree); 5436 5437 } 5438 break; 5439 5440 } 5441 retval.stop = input.LT(-1); 5442 5443 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 5444 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 5445 5446 } 5447 catch (RecognitionException re) { 5448 reportError(re); 5449 recover(input,re); 5450 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 5451 } 5452 finally { 5453 // do for sure before leaving 5454 } 5455 return retval; 5456 } 5457 // $ANTLR end "integral_literal" 5458 5459 5460 public static class fixed_32bit_literal_return extends ParserRuleReturnScope { 5461 CommonTree tree; 5462 @Override getTree()5463 public CommonTree getTree() { return tree; } 5464 }; 5465 5466 5467 // $ANTLR start "fixed_32bit_literal" 5468 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:659:1: fixed_32bit_literal : ( LONG_LITERAL | integer_literal | SHORT_LITERAL | BYTE_LITERAL | float_literal | CHAR_LITERAL | BOOL_LITERAL ); fixed_32bit_literal()5469 public final smaliParser.fixed_32bit_literal_return fixed_32bit_literal() throws RecognitionException { 5470 smaliParser.fixed_32bit_literal_return retval = new smaliParser.fixed_32bit_literal_return(); 5471 retval.start = input.LT(1); 5472 5473 CommonTree root_0 = null; 5474 5475 Token LONG_LITERAL131=null; 5476 Token SHORT_LITERAL133=null; 5477 Token BYTE_LITERAL134=null; 5478 Token CHAR_LITERAL136=null; 5479 Token BOOL_LITERAL137=null; 5480 ParserRuleReturnScope integer_literal132 =null; 5481 ParserRuleReturnScope float_literal135 =null; 5482 5483 CommonTree LONG_LITERAL131_tree=null; 5484 CommonTree SHORT_LITERAL133_tree=null; 5485 CommonTree BYTE_LITERAL134_tree=null; 5486 CommonTree CHAR_LITERAL136_tree=null; 5487 CommonTree BOOL_LITERAL137_tree=null; 5488 5489 try { 5490 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:660:3: ( LONG_LITERAL | integer_literal | SHORT_LITERAL | BYTE_LITERAL | float_literal | CHAR_LITERAL | BOOL_LITERAL ) 5491 int alt21=7; 5492 switch ( input.LA(1) ) { 5493 case LONG_LITERAL: 5494 { 5495 alt21=1; 5496 } 5497 break; 5498 case NEGATIVE_INTEGER_LITERAL: 5499 case POSITIVE_INTEGER_LITERAL: 5500 { 5501 alt21=2; 5502 } 5503 break; 5504 case SHORT_LITERAL: 5505 { 5506 alt21=3; 5507 } 5508 break; 5509 case BYTE_LITERAL: 5510 { 5511 alt21=4; 5512 } 5513 break; 5514 case FLOAT_LITERAL: 5515 case FLOAT_LITERAL_OR_ID: 5516 { 5517 alt21=5; 5518 } 5519 break; 5520 case CHAR_LITERAL: 5521 { 5522 alt21=6; 5523 } 5524 break; 5525 case BOOL_LITERAL: 5526 { 5527 alt21=7; 5528 } 5529 break; 5530 default: 5531 NoViableAltException nvae = 5532 new NoViableAltException("", 21, 0, input); 5533 throw nvae; 5534 } 5535 switch (alt21) { 5536 case 1 : 5537 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:660:5: LONG_LITERAL 5538 { 5539 root_0 = (CommonTree)adaptor.nil(); 5540 5541 5542 LONG_LITERAL131=(Token)match(input,LONG_LITERAL,FOLLOW_LONG_LITERAL_in_fixed_32bit_literal2658); 5543 LONG_LITERAL131_tree = (CommonTree)adaptor.create(LONG_LITERAL131); 5544 adaptor.addChild(root_0, LONG_LITERAL131_tree); 5545 5546 } 5547 break; 5548 case 2 : 5549 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:661:5: integer_literal 5550 { 5551 root_0 = (CommonTree)adaptor.nil(); 5552 5553 5554 pushFollow(FOLLOW_integer_literal_in_fixed_32bit_literal2664); 5555 integer_literal132=integer_literal(); 5556 state._fsp--; 5557 5558 adaptor.addChild(root_0, integer_literal132.getTree()); 5559 5560 } 5561 break; 5562 case 3 : 5563 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:662:5: SHORT_LITERAL 5564 { 5565 root_0 = (CommonTree)adaptor.nil(); 5566 5567 5568 SHORT_LITERAL133=(Token)match(input,SHORT_LITERAL,FOLLOW_SHORT_LITERAL_in_fixed_32bit_literal2670); 5569 SHORT_LITERAL133_tree = (CommonTree)adaptor.create(SHORT_LITERAL133); 5570 adaptor.addChild(root_0, SHORT_LITERAL133_tree); 5571 5572 } 5573 break; 5574 case 4 : 5575 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:663:5: BYTE_LITERAL 5576 { 5577 root_0 = (CommonTree)adaptor.nil(); 5578 5579 5580 BYTE_LITERAL134=(Token)match(input,BYTE_LITERAL,FOLLOW_BYTE_LITERAL_in_fixed_32bit_literal2676); 5581 BYTE_LITERAL134_tree = (CommonTree)adaptor.create(BYTE_LITERAL134); 5582 adaptor.addChild(root_0, BYTE_LITERAL134_tree); 5583 5584 } 5585 break; 5586 case 5 : 5587 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:664:5: float_literal 5588 { 5589 root_0 = (CommonTree)adaptor.nil(); 5590 5591 5592 pushFollow(FOLLOW_float_literal_in_fixed_32bit_literal2682); 5593 float_literal135=float_literal(); 5594 state._fsp--; 5595 5596 adaptor.addChild(root_0, float_literal135.getTree()); 5597 5598 } 5599 break; 5600 case 6 : 5601 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:665:5: CHAR_LITERAL 5602 { 5603 root_0 = (CommonTree)adaptor.nil(); 5604 5605 5606 CHAR_LITERAL136=(Token)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_fixed_32bit_literal2688); 5607 CHAR_LITERAL136_tree = (CommonTree)adaptor.create(CHAR_LITERAL136); 5608 adaptor.addChild(root_0, CHAR_LITERAL136_tree); 5609 5610 } 5611 break; 5612 case 7 : 5613 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:666:5: BOOL_LITERAL 5614 { 5615 root_0 = (CommonTree)adaptor.nil(); 5616 5617 5618 BOOL_LITERAL137=(Token)match(input,BOOL_LITERAL,FOLLOW_BOOL_LITERAL_in_fixed_32bit_literal2694); 5619 BOOL_LITERAL137_tree = (CommonTree)adaptor.create(BOOL_LITERAL137); 5620 adaptor.addChild(root_0, BOOL_LITERAL137_tree); 5621 5622 } 5623 break; 5624 5625 } 5626 retval.stop = input.LT(-1); 5627 5628 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 5629 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 5630 5631 } 5632 catch (RecognitionException re) { 5633 reportError(re); 5634 recover(input,re); 5635 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 5636 } 5637 finally { 5638 // do for sure before leaving 5639 } 5640 return retval; 5641 } 5642 // $ANTLR end "fixed_32bit_literal" 5643 5644 5645 public static class fixed_literal_return extends ParserRuleReturnScope { 5646 CommonTree tree; 5647 @Override getTree()5648 public CommonTree getTree() { return tree; } 5649 }; 5650 5651 5652 // $ANTLR start "fixed_literal" 5653 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:668:1: fixed_literal : ( integer_literal | LONG_LITERAL | SHORT_LITERAL | BYTE_LITERAL | float_literal | double_literal | CHAR_LITERAL | BOOL_LITERAL ); fixed_literal()5654 public final smaliParser.fixed_literal_return fixed_literal() throws RecognitionException { 5655 smaliParser.fixed_literal_return retval = new smaliParser.fixed_literal_return(); 5656 retval.start = input.LT(1); 5657 5658 CommonTree root_0 = null; 5659 5660 Token LONG_LITERAL139=null; 5661 Token SHORT_LITERAL140=null; 5662 Token BYTE_LITERAL141=null; 5663 Token CHAR_LITERAL144=null; 5664 Token BOOL_LITERAL145=null; 5665 ParserRuleReturnScope integer_literal138 =null; 5666 ParserRuleReturnScope float_literal142 =null; 5667 ParserRuleReturnScope double_literal143 =null; 5668 5669 CommonTree LONG_LITERAL139_tree=null; 5670 CommonTree SHORT_LITERAL140_tree=null; 5671 CommonTree BYTE_LITERAL141_tree=null; 5672 CommonTree CHAR_LITERAL144_tree=null; 5673 CommonTree BOOL_LITERAL145_tree=null; 5674 5675 try { 5676 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:669:3: ( integer_literal | LONG_LITERAL | SHORT_LITERAL | BYTE_LITERAL | float_literal | double_literal | CHAR_LITERAL | BOOL_LITERAL ) 5677 int alt22=8; 5678 switch ( input.LA(1) ) { 5679 case NEGATIVE_INTEGER_LITERAL: 5680 case POSITIVE_INTEGER_LITERAL: 5681 { 5682 alt22=1; 5683 } 5684 break; 5685 case LONG_LITERAL: 5686 { 5687 alt22=2; 5688 } 5689 break; 5690 case SHORT_LITERAL: 5691 { 5692 alt22=3; 5693 } 5694 break; 5695 case BYTE_LITERAL: 5696 { 5697 alt22=4; 5698 } 5699 break; 5700 case FLOAT_LITERAL: 5701 case FLOAT_LITERAL_OR_ID: 5702 { 5703 alt22=5; 5704 } 5705 break; 5706 case DOUBLE_LITERAL: 5707 case DOUBLE_LITERAL_OR_ID: 5708 { 5709 alt22=6; 5710 } 5711 break; 5712 case CHAR_LITERAL: 5713 { 5714 alt22=7; 5715 } 5716 break; 5717 case BOOL_LITERAL: 5718 { 5719 alt22=8; 5720 } 5721 break; 5722 default: 5723 NoViableAltException nvae = 5724 new NoViableAltException("", 22, 0, input); 5725 throw nvae; 5726 } 5727 switch (alt22) { 5728 case 1 : 5729 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:669:5: integer_literal 5730 { 5731 root_0 = (CommonTree)adaptor.nil(); 5732 5733 5734 pushFollow(FOLLOW_integer_literal_in_fixed_literal2704); 5735 integer_literal138=integer_literal(); 5736 state._fsp--; 5737 5738 adaptor.addChild(root_0, integer_literal138.getTree()); 5739 5740 } 5741 break; 5742 case 2 : 5743 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:670:5: LONG_LITERAL 5744 { 5745 root_0 = (CommonTree)adaptor.nil(); 5746 5747 5748 LONG_LITERAL139=(Token)match(input,LONG_LITERAL,FOLLOW_LONG_LITERAL_in_fixed_literal2710); 5749 LONG_LITERAL139_tree = (CommonTree)adaptor.create(LONG_LITERAL139); 5750 adaptor.addChild(root_0, LONG_LITERAL139_tree); 5751 5752 } 5753 break; 5754 case 3 : 5755 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:671:5: SHORT_LITERAL 5756 { 5757 root_0 = (CommonTree)adaptor.nil(); 5758 5759 5760 SHORT_LITERAL140=(Token)match(input,SHORT_LITERAL,FOLLOW_SHORT_LITERAL_in_fixed_literal2716); 5761 SHORT_LITERAL140_tree = (CommonTree)adaptor.create(SHORT_LITERAL140); 5762 adaptor.addChild(root_0, SHORT_LITERAL140_tree); 5763 5764 } 5765 break; 5766 case 4 : 5767 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:672:5: BYTE_LITERAL 5768 { 5769 root_0 = (CommonTree)adaptor.nil(); 5770 5771 5772 BYTE_LITERAL141=(Token)match(input,BYTE_LITERAL,FOLLOW_BYTE_LITERAL_in_fixed_literal2722); 5773 BYTE_LITERAL141_tree = (CommonTree)adaptor.create(BYTE_LITERAL141); 5774 adaptor.addChild(root_0, BYTE_LITERAL141_tree); 5775 5776 } 5777 break; 5778 case 5 : 5779 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:673:5: float_literal 5780 { 5781 root_0 = (CommonTree)adaptor.nil(); 5782 5783 5784 pushFollow(FOLLOW_float_literal_in_fixed_literal2728); 5785 float_literal142=float_literal(); 5786 state._fsp--; 5787 5788 adaptor.addChild(root_0, float_literal142.getTree()); 5789 5790 } 5791 break; 5792 case 6 : 5793 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:674:5: double_literal 5794 { 5795 root_0 = (CommonTree)adaptor.nil(); 5796 5797 5798 pushFollow(FOLLOW_double_literal_in_fixed_literal2734); 5799 double_literal143=double_literal(); 5800 state._fsp--; 5801 5802 adaptor.addChild(root_0, double_literal143.getTree()); 5803 5804 } 5805 break; 5806 case 7 : 5807 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:675:5: CHAR_LITERAL 5808 { 5809 root_0 = (CommonTree)adaptor.nil(); 5810 5811 5812 CHAR_LITERAL144=(Token)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_fixed_literal2740); 5813 CHAR_LITERAL144_tree = (CommonTree)adaptor.create(CHAR_LITERAL144); 5814 adaptor.addChild(root_0, CHAR_LITERAL144_tree); 5815 5816 } 5817 break; 5818 case 8 : 5819 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:676:5: BOOL_LITERAL 5820 { 5821 root_0 = (CommonTree)adaptor.nil(); 5822 5823 5824 BOOL_LITERAL145=(Token)match(input,BOOL_LITERAL,FOLLOW_BOOL_LITERAL_in_fixed_literal2746); 5825 BOOL_LITERAL145_tree = (CommonTree)adaptor.create(BOOL_LITERAL145); 5826 adaptor.addChild(root_0, BOOL_LITERAL145_tree); 5827 5828 } 5829 break; 5830 5831 } 5832 retval.stop = input.LT(-1); 5833 5834 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 5835 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 5836 5837 } 5838 catch (RecognitionException re) { 5839 reportError(re); 5840 recover(input,re); 5841 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 5842 } 5843 finally { 5844 // do for sure before leaving 5845 } 5846 return retval; 5847 } 5848 // $ANTLR end "fixed_literal" 5849 5850 5851 public static class array_literal_return extends ParserRuleReturnScope { 5852 CommonTree tree; 5853 @Override getTree()5854 public CommonTree getTree() { return tree; } 5855 }; 5856 5857 5858 // $ANTLR start "array_literal" 5859 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:678:1: array_literal : OPEN_BRACE ( literal ( COMMA literal )* |) CLOSE_BRACE -> ^( I_ENCODED_ARRAY[$start, \"I_ENCODED_ARRAY\"] ( literal )* ) ; array_literal()5860 public final smaliParser.array_literal_return array_literal() throws RecognitionException { 5861 smaliParser.array_literal_return retval = new smaliParser.array_literal_return(); 5862 retval.start = input.LT(1); 5863 5864 CommonTree root_0 = null; 5865 5866 Token OPEN_BRACE146=null; 5867 Token COMMA148=null; 5868 Token CLOSE_BRACE150=null; 5869 ParserRuleReturnScope literal147 =null; 5870 ParserRuleReturnScope literal149 =null; 5871 5872 CommonTree OPEN_BRACE146_tree=null; 5873 CommonTree COMMA148_tree=null; 5874 CommonTree CLOSE_BRACE150_tree=null; 5875 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 5876 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 5877 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 5878 RewriteRuleSubtreeStream stream_literal=new RewriteRuleSubtreeStream(adaptor,"rule literal"); 5879 5880 try { 5881 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:679:3: ( OPEN_BRACE ( literal ( COMMA literal )* |) CLOSE_BRACE -> ^( I_ENCODED_ARRAY[$start, \"I_ENCODED_ARRAY\"] ( literal )* ) ) 5882 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:679:5: OPEN_BRACE ( literal ( COMMA literal )* |) CLOSE_BRACE 5883 { 5884 OPEN_BRACE146=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_array_literal2756); 5885 stream_OPEN_BRACE.add(OPEN_BRACE146); 5886 5887 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:679:16: ( literal ( COMMA literal )* |) 5888 int alt24=2; 5889 int LA24_0 = input.LA(1); 5890 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_FORMAT25x)||(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)) ) { 5891 alt24=1; 5892 } 5893 else if ( (LA24_0==CLOSE_BRACE) ) { 5894 alt24=2; 5895 } 5896 5897 else { 5898 NoViableAltException nvae = 5899 new NoViableAltException("", 24, 0, input); 5900 throw nvae; 5901 } 5902 5903 switch (alt24) { 5904 case 1 : 5905 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:679:17: literal ( COMMA literal )* 5906 { 5907 pushFollow(FOLLOW_literal_in_array_literal2759); 5908 literal147=literal(); 5909 state._fsp--; 5910 5911 stream_literal.add(literal147.getTree()); 5912 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:679:25: ( COMMA literal )* 5913 loop23: 5914 while (true) { 5915 int alt23=2; 5916 int LA23_0 = input.LA(1); 5917 if ( (LA23_0==COMMA) ) { 5918 alt23=1; 5919 } 5920 5921 switch (alt23) { 5922 case 1 : 5923 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:679:26: COMMA literal 5924 { 5925 COMMA148=(Token)match(input,COMMA,FOLLOW_COMMA_in_array_literal2762); 5926 stream_COMMA.add(COMMA148); 5927 5928 pushFollow(FOLLOW_literal_in_array_literal2764); 5929 literal149=literal(); 5930 state._fsp--; 5931 5932 stream_literal.add(literal149.getTree()); 5933 } 5934 break; 5935 5936 default : 5937 break loop23; 5938 } 5939 } 5940 5941 } 5942 break; 5943 case 2 : 5944 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:679:44: 5945 { 5946 } 5947 break; 5948 5949 } 5950 5951 CLOSE_BRACE150=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_array_literal2772); 5952 stream_CLOSE_BRACE.add(CLOSE_BRACE150); 5953 5954 // AST REWRITE 5955 // elements: literal 5956 // token labels: 5957 // rule labels: retval 5958 // token list labels: 5959 // rule list labels: 5960 // wildcard labels: 5961 retval.tree = root_0; 5962 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 5963 5964 root_0 = (CommonTree)adaptor.nil(); 5965 // 680:5: -> ^( I_ENCODED_ARRAY[$start, \"I_ENCODED_ARRAY\"] ( literal )* ) 5966 { 5967 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:680:8: ^( I_ENCODED_ARRAY[$start, \"I_ENCODED_ARRAY\"] ( literal )* ) 5968 { 5969 CommonTree root_1 = (CommonTree)adaptor.nil(); 5970 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ENCODED_ARRAY, (retval.start), "I_ENCODED_ARRAY"), root_1); 5971 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:680:53: ( literal )* 5972 while ( stream_literal.hasNext() ) { 5973 adaptor.addChild(root_1, stream_literal.nextTree()); 5974 } 5975 stream_literal.reset(); 5976 5977 adaptor.addChild(root_0, root_1); 5978 } 5979 5980 } 5981 5982 5983 retval.tree = root_0; 5984 5985 } 5986 5987 retval.stop = input.LT(-1); 5988 5989 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 5990 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 5991 5992 } 5993 catch (RecognitionException re) { 5994 reportError(re); 5995 recover(input,re); 5996 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 5997 } 5998 finally { 5999 // do for sure before leaving 6000 } 6001 return retval; 6002 } 6003 // $ANTLR end "array_literal" 6004 6005 6006 public static class annotation_element_return extends ParserRuleReturnScope { 6007 CommonTree tree; 6008 @Override getTree()6009 public CommonTree getTree() { return tree; } 6010 }; 6011 6012 6013 // $ANTLR start "annotation_element" 6014 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:682:1: annotation_element : simple_name EQUAL literal -> ^( I_ANNOTATION_ELEMENT[$start, \"I_ANNOTATION_ELEMENT\"] simple_name literal ) ; annotation_element()6015 public final smaliParser.annotation_element_return annotation_element() throws RecognitionException { 6016 smaliParser.annotation_element_return retval = new smaliParser.annotation_element_return(); 6017 retval.start = input.LT(1); 6018 6019 CommonTree root_0 = null; 6020 6021 Token EQUAL152=null; 6022 ParserRuleReturnScope simple_name151 =null; 6023 ParserRuleReturnScope literal153 =null; 6024 6025 CommonTree EQUAL152_tree=null; 6026 RewriteRuleTokenStream stream_EQUAL=new RewriteRuleTokenStream(adaptor,"token EQUAL"); 6027 RewriteRuleSubtreeStream stream_simple_name=new RewriteRuleSubtreeStream(adaptor,"rule simple_name"); 6028 RewriteRuleSubtreeStream stream_literal=new RewriteRuleSubtreeStream(adaptor,"rule literal"); 6029 6030 try { 6031 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:683:3: ( simple_name EQUAL literal -> ^( I_ANNOTATION_ELEMENT[$start, \"I_ANNOTATION_ELEMENT\"] simple_name literal ) ) 6032 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:683:5: simple_name EQUAL literal 6033 { 6034 pushFollow(FOLLOW_simple_name_in_annotation_element2796); 6035 simple_name151=simple_name(); 6036 state._fsp--; 6037 6038 stream_simple_name.add(simple_name151.getTree()); 6039 EQUAL152=(Token)match(input,EQUAL,FOLLOW_EQUAL_in_annotation_element2798); 6040 stream_EQUAL.add(EQUAL152); 6041 6042 pushFollow(FOLLOW_literal_in_annotation_element2800); 6043 literal153=literal(); 6044 state._fsp--; 6045 6046 stream_literal.add(literal153.getTree()); 6047 // AST REWRITE 6048 // elements: simple_name, literal 6049 // token labels: 6050 // rule labels: retval 6051 // token list labels: 6052 // rule list labels: 6053 // wildcard labels: 6054 retval.tree = root_0; 6055 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 6056 6057 root_0 = (CommonTree)adaptor.nil(); 6058 // 684:5: -> ^( I_ANNOTATION_ELEMENT[$start, \"I_ANNOTATION_ELEMENT\"] simple_name literal ) 6059 { 6060 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:684:8: ^( I_ANNOTATION_ELEMENT[$start, \"I_ANNOTATION_ELEMENT\"] simple_name literal ) 6061 { 6062 CommonTree root_1 = (CommonTree)adaptor.nil(); 6063 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATION_ELEMENT, (retval.start), "I_ANNOTATION_ELEMENT"), root_1); 6064 adaptor.addChild(root_1, stream_simple_name.nextTree()); 6065 adaptor.addChild(root_1, stream_literal.nextTree()); 6066 adaptor.addChild(root_0, root_1); 6067 } 6068 6069 } 6070 6071 6072 retval.tree = root_0; 6073 6074 } 6075 6076 retval.stop = input.LT(-1); 6077 6078 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 6079 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 6080 6081 } 6082 catch (RecognitionException re) { 6083 reportError(re); 6084 recover(input,re); 6085 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 6086 } 6087 finally { 6088 // do for sure before leaving 6089 } 6090 return retval; 6091 } 6092 // $ANTLR end "annotation_element" 6093 6094 6095 public static class annotation_return extends ParserRuleReturnScope { 6096 CommonTree tree; 6097 @Override getTree()6098 public CommonTree getTree() { return tree; } 6099 }; 6100 6101 6102 // $ANTLR start "annotation" 6103 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:686: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 )* ) ) ; annotation()6104 public final smaliParser.annotation_return annotation() throws RecognitionException { 6105 smaliParser.annotation_return retval = new smaliParser.annotation_return(); 6106 retval.start = input.LT(1); 6107 6108 CommonTree root_0 = null; 6109 6110 Token ANNOTATION_DIRECTIVE154=null; 6111 Token ANNOTATION_VISIBILITY155=null; 6112 Token CLASS_DESCRIPTOR156=null; 6113 Token END_ANNOTATION_DIRECTIVE158=null; 6114 ParserRuleReturnScope annotation_element157 =null; 6115 6116 CommonTree ANNOTATION_DIRECTIVE154_tree=null; 6117 CommonTree ANNOTATION_VISIBILITY155_tree=null; 6118 CommonTree CLASS_DESCRIPTOR156_tree=null; 6119 CommonTree END_ANNOTATION_DIRECTIVE158_tree=null; 6120 RewriteRuleTokenStream stream_ANNOTATION_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token ANNOTATION_DIRECTIVE"); 6121 RewriteRuleTokenStream stream_END_ANNOTATION_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_ANNOTATION_DIRECTIVE"); 6122 RewriteRuleTokenStream stream_ANNOTATION_VISIBILITY=new RewriteRuleTokenStream(adaptor,"token ANNOTATION_VISIBILITY"); 6123 RewriteRuleTokenStream stream_CLASS_DESCRIPTOR=new RewriteRuleTokenStream(adaptor,"token CLASS_DESCRIPTOR"); 6124 RewriteRuleSubtreeStream stream_annotation_element=new RewriteRuleSubtreeStream(adaptor,"rule annotation_element"); 6125 6126 try { 6127 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:687: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 )* ) ) ) 6128 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:687:5: ANNOTATION_DIRECTIVE ANNOTATION_VISIBILITY CLASS_DESCRIPTOR ( annotation_element )* END_ANNOTATION_DIRECTIVE 6129 { 6130 ANNOTATION_DIRECTIVE154=(Token)match(input,ANNOTATION_DIRECTIVE,FOLLOW_ANNOTATION_DIRECTIVE_in_annotation2825); 6131 stream_ANNOTATION_DIRECTIVE.add(ANNOTATION_DIRECTIVE154); 6132 6133 ANNOTATION_VISIBILITY155=(Token)match(input,ANNOTATION_VISIBILITY,FOLLOW_ANNOTATION_VISIBILITY_in_annotation2827); 6134 stream_ANNOTATION_VISIBILITY.add(ANNOTATION_VISIBILITY155); 6135 6136 CLASS_DESCRIPTOR156=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_annotation2829); 6137 stream_CLASS_DESCRIPTOR.add(CLASS_DESCRIPTOR156); 6138 6139 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:688:5: ( annotation_element )* 6140 loop25: 6141 while (true) { 6142 int alt25=2; 6143 int LA25_0 = input.LA(1); 6144 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_FORMAT25x)||(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)) ) { 6145 alt25=1; 6146 } 6147 6148 switch (alt25) { 6149 case 1 : 6150 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:688:5: annotation_element 6151 { 6152 pushFollow(FOLLOW_annotation_element_in_annotation2835); 6153 annotation_element157=annotation_element(); 6154 state._fsp--; 6155 6156 stream_annotation_element.add(annotation_element157.getTree()); 6157 } 6158 break; 6159 6160 default : 6161 break loop25; 6162 } 6163 } 6164 6165 END_ANNOTATION_DIRECTIVE158=(Token)match(input,END_ANNOTATION_DIRECTIVE,FOLLOW_END_ANNOTATION_DIRECTIVE_in_annotation2838); 6166 stream_END_ANNOTATION_DIRECTIVE.add(END_ANNOTATION_DIRECTIVE158); 6167 6168 // AST REWRITE 6169 // elements: CLASS_DESCRIPTOR, ANNOTATION_VISIBILITY, annotation_element 6170 // token labels: 6171 // rule labels: retval 6172 // token list labels: 6173 // rule list labels: 6174 // wildcard labels: 6175 retval.tree = root_0; 6176 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 6177 6178 root_0 = (CommonTree)adaptor.nil(); 6179 // 689:5: -> ^( I_ANNOTATION[$start, \"I_ANNOTATION\"] ANNOTATION_VISIBILITY ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) ) 6180 { 6181 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:689:8: ^( I_ANNOTATION[$start, \"I_ANNOTATION\"] ANNOTATION_VISIBILITY ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) ) 6182 { 6183 CommonTree root_1 = (CommonTree)adaptor.nil(); 6184 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATION, (retval.start), "I_ANNOTATION"), root_1); 6185 adaptor.addChild(root_1, stream_ANNOTATION_VISIBILITY.nextNode()); 6186 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:689:69: ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) 6187 { 6188 CommonTree root_2 = (CommonTree)adaptor.nil(); 6189 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SUBANNOTATION, (retval.start), "I_SUBANNOTATION"), root_2); 6190 adaptor.addChild(root_2, stream_CLASS_DESCRIPTOR.nextNode()); 6191 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:689:131: ( annotation_element )* 6192 while ( stream_annotation_element.hasNext() ) { 6193 adaptor.addChild(root_2, stream_annotation_element.nextTree()); 6194 } 6195 stream_annotation_element.reset(); 6196 6197 adaptor.addChild(root_1, root_2); 6198 } 6199 6200 adaptor.addChild(root_0, root_1); 6201 } 6202 6203 } 6204 6205 6206 retval.tree = root_0; 6207 6208 } 6209 6210 retval.stop = input.LT(-1); 6211 6212 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 6213 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 6214 6215 } 6216 catch (RecognitionException re) { 6217 reportError(re); 6218 recover(input,re); 6219 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 6220 } 6221 finally { 6222 // do for sure before leaving 6223 } 6224 return retval; 6225 } 6226 // $ANTLR end "annotation" 6227 6228 6229 public static class subannotation_return extends ParserRuleReturnScope { 6230 CommonTree tree; 6231 @Override getTree()6232 public CommonTree getTree() { return tree; } 6233 }; 6234 6235 6236 // $ANTLR start "subannotation" 6237 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:691:1: subannotation : SUBANNOTATION_DIRECTIVE CLASS_DESCRIPTOR ( annotation_element )* END_SUBANNOTATION_DIRECTIVE -> ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) ; subannotation()6238 public final smaliParser.subannotation_return subannotation() throws RecognitionException { 6239 smaliParser.subannotation_return retval = new smaliParser.subannotation_return(); 6240 retval.start = input.LT(1); 6241 6242 CommonTree root_0 = null; 6243 6244 Token SUBANNOTATION_DIRECTIVE159=null; 6245 Token CLASS_DESCRIPTOR160=null; 6246 Token END_SUBANNOTATION_DIRECTIVE162=null; 6247 ParserRuleReturnScope annotation_element161 =null; 6248 6249 CommonTree SUBANNOTATION_DIRECTIVE159_tree=null; 6250 CommonTree CLASS_DESCRIPTOR160_tree=null; 6251 CommonTree END_SUBANNOTATION_DIRECTIVE162_tree=null; 6252 RewriteRuleTokenStream stream_SUBANNOTATION_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token SUBANNOTATION_DIRECTIVE"); 6253 RewriteRuleTokenStream stream_END_SUBANNOTATION_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_SUBANNOTATION_DIRECTIVE"); 6254 RewriteRuleTokenStream stream_CLASS_DESCRIPTOR=new RewriteRuleTokenStream(adaptor,"token CLASS_DESCRIPTOR"); 6255 RewriteRuleSubtreeStream stream_annotation_element=new RewriteRuleSubtreeStream(adaptor,"rule annotation_element"); 6256 6257 try { 6258 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:692:3: ( SUBANNOTATION_DIRECTIVE CLASS_DESCRIPTOR ( annotation_element )* END_SUBANNOTATION_DIRECTIVE -> ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) ) 6259 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:692:5: SUBANNOTATION_DIRECTIVE CLASS_DESCRIPTOR ( annotation_element )* END_SUBANNOTATION_DIRECTIVE 6260 { 6261 SUBANNOTATION_DIRECTIVE159=(Token)match(input,SUBANNOTATION_DIRECTIVE,FOLLOW_SUBANNOTATION_DIRECTIVE_in_subannotation2871); 6262 stream_SUBANNOTATION_DIRECTIVE.add(SUBANNOTATION_DIRECTIVE159); 6263 6264 CLASS_DESCRIPTOR160=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_subannotation2873); 6265 stream_CLASS_DESCRIPTOR.add(CLASS_DESCRIPTOR160); 6266 6267 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:692:46: ( annotation_element )* 6268 loop26: 6269 while (true) { 6270 int alt26=2; 6271 int LA26_0 = input.LA(1); 6272 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_FORMAT25x)||(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)) ) { 6273 alt26=1; 6274 } 6275 6276 switch (alt26) { 6277 case 1 : 6278 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:692:46: annotation_element 6279 { 6280 pushFollow(FOLLOW_annotation_element_in_subannotation2875); 6281 annotation_element161=annotation_element(); 6282 state._fsp--; 6283 6284 stream_annotation_element.add(annotation_element161.getTree()); 6285 } 6286 break; 6287 6288 default : 6289 break loop26; 6290 } 6291 } 6292 6293 END_SUBANNOTATION_DIRECTIVE162=(Token)match(input,END_SUBANNOTATION_DIRECTIVE,FOLLOW_END_SUBANNOTATION_DIRECTIVE_in_subannotation2878); 6294 stream_END_SUBANNOTATION_DIRECTIVE.add(END_SUBANNOTATION_DIRECTIVE162); 6295 6296 // AST REWRITE 6297 // elements: annotation_element, CLASS_DESCRIPTOR 6298 // token labels: 6299 // rule labels: retval 6300 // token list labels: 6301 // rule list labels: 6302 // wildcard labels: 6303 retval.tree = root_0; 6304 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 6305 6306 root_0 = (CommonTree)adaptor.nil(); 6307 // 693:5: -> ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) 6308 { 6309 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:693:8: ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) 6310 { 6311 CommonTree root_1 = (CommonTree)adaptor.nil(); 6312 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SUBANNOTATION, (retval.start), "I_SUBANNOTATION"), root_1); 6313 adaptor.addChild(root_1, stream_CLASS_DESCRIPTOR.nextNode()); 6314 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:693:70: ( annotation_element )* 6315 while ( stream_annotation_element.hasNext() ) { 6316 adaptor.addChild(root_1, stream_annotation_element.nextTree()); 6317 } 6318 stream_annotation_element.reset(); 6319 6320 adaptor.addChild(root_0, root_1); 6321 } 6322 6323 } 6324 6325 6326 retval.tree = root_0; 6327 6328 } 6329 6330 retval.stop = input.LT(-1); 6331 6332 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 6333 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 6334 6335 } 6336 catch (RecognitionException re) { 6337 reportError(re); 6338 recover(input,re); 6339 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 6340 } 6341 finally { 6342 // do for sure before leaving 6343 } 6344 return retval; 6345 } 6346 // $ANTLR end "subannotation" 6347 6348 6349 public static class enum_literal_return extends ParserRuleReturnScope { 6350 CommonTree tree; 6351 @Override getTree()6352 public CommonTree getTree() { return tree; } 6353 }; 6354 6355 6356 // $ANTLR start "enum_literal" 6357 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:695: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 ) ; enum_literal()6358 public final smaliParser.enum_literal_return enum_literal() throws RecognitionException { 6359 smaliParser.enum_literal_return retval = new smaliParser.enum_literal_return(); 6360 retval.start = input.LT(1); 6361 6362 CommonTree root_0 = null; 6363 6364 Token ENUM_DIRECTIVE163=null; 6365 Token ARROW165=null; 6366 Token COLON167=null; 6367 ParserRuleReturnScope reference_type_descriptor164 =null; 6368 ParserRuleReturnScope simple_name166 =null; 6369 ParserRuleReturnScope reference_type_descriptor168 =null; 6370 6371 CommonTree ENUM_DIRECTIVE163_tree=null; 6372 CommonTree ARROW165_tree=null; 6373 CommonTree COLON167_tree=null; 6374 RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON"); 6375 RewriteRuleTokenStream stream_ENUM_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token ENUM_DIRECTIVE"); 6376 RewriteRuleTokenStream stream_ARROW=new RewriteRuleTokenStream(adaptor,"token ARROW"); 6377 RewriteRuleSubtreeStream stream_reference_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule reference_type_descriptor"); 6378 RewriteRuleSubtreeStream stream_simple_name=new RewriteRuleSubtreeStream(adaptor,"rule simple_name"); 6379 6380 try { 6381 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:696:3: ( ENUM_DIRECTIVE reference_type_descriptor ARROW simple_name COLON reference_type_descriptor -> ^( I_ENCODED_ENUM reference_type_descriptor simple_name reference_type_descriptor ) ) 6382 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:696:5: ENUM_DIRECTIVE reference_type_descriptor ARROW simple_name COLON reference_type_descriptor 6383 { 6384 ENUM_DIRECTIVE163=(Token)match(input,ENUM_DIRECTIVE,FOLLOW_ENUM_DIRECTIVE_in_enum_literal2904); 6385 stream_ENUM_DIRECTIVE.add(ENUM_DIRECTIVE163); 6386 6387 pushFollow(FOLLOW_reference_type_descriptor_in_enum_literal2906); 6388 reference_type_descriptor164=reference_type_descriptor(); 6389 state._fsp--; 6390 6391 stream_reference_type_descriptor.add(reference_type_descriptor164.getTree()); 6392 ARROW165=(Token)match(input,ARROW,FOLLOW_ARROW_in_enum_literal2908); 6393 stream_ARROW.add(ARROW165); 6394 6395 pushFollow(FOLLOW_simple_name_in_enum_literal2910); 6396 simple_name166=simple_name(); 6397 state._fsp--; 6398 6399 stream_simple_name.add(simple_name166.getTree()); 6400 COLON167=(Token)match(input,COLON,FOLLOW_COLON_in_enum_literal2912); 6401 stream_COLON.add(COLON167); 6402 6403 pushFollow(FOLLOW_reference_type_descriptor_in_enum_literal2914); 6404 reference_type_descriptor168=reference_type_descriptor(); 6405 state._fsp--; 6406 6407 stream_reference_type_descriptor.add(reference_type_descriptor168.getTree()); 6408 // AST REWRITE 6409 // elements: reference_type_descriptor, simple_name, reference_type_descriptor 6410 // token labels: 6411 // rule labels: retval 6412 // token list labels: 6413 // rule list labels: 6414 // wildcard labels: 6415 retval.tree = root_0; 6416 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 6417 6418 root_0 = (CommonTree)adaptor.nil(); 6419 // 697:3: -> ^( I_ENCODED_ENUM reference_type_descriptor simple_name reference_type_descriptor ) 6420 { 6421 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:697:6: ^( I_ENCODED_ENUM reference_type_descriptor simple_name reference_type_descriptor ) 6422 { 6423 CommonTree root_1 = (CommonTree)adaptor.nil(); 6424 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ENCODED_ENUM, "I_ENCODED_ENUM"), root_1); 6425 adaptor.addChild(root_1, stream_reference_type_descriptor.nextTree()); 6426 adaptor.addChild(root_1, stream_simple_name.nextTree()); 6427 adaptor.addChild(root_1, stream_reference_type_descriptor.nextTree()); 6428 adaptor.addChild(root_0, root_1); 6429 } 6430 6431 } 6432 6433 6434 retval.tree = root_0; 6435 6436 } 6437 6438 retval.stop = input.LT(-1); 6439 6440 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 6441 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 6442 6443 } 6444 catch (RecognitionException re) { 6445 reportError(re); 6446 recover(input,re); 6447 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 6448 } 6449 finally { 6450 // do for sure before leaving 6451 } 6452 return retval; 6453 } 6454 // $ANTLR end "enum_literal" 6455 6456 6457 public static class type_field_method_literal_return extends ParserRuleReturnScope { 6458 CommonTree tree; 6459 @Override getTree()6460 public CommonTree getTree() { return tree; } 6461 }; 6462 6463 6464 // $ANTLR start "type_field_method_literal" 6465 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:699: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 ); type_field_method_literal()6466 public final smaliParser.type_field_method_literal_return type_field_method_literal() throws RecognitionException { 6467 smaliParser.type_field_method_literal_return retval = new smaliParser.type_field_method_literal_return(); 6468 retval.start = input.LT(1); 6469 6470 CommonTree root_0 = null; 6471 6472 Token ARROW171=null; 6473 Token COLON173=null; 6474 Token PRIMITIVE_TYPE177=null; 6475 Token VOID_TYPE178=null; 6476 ParserRuleReturnScope reference_type_descriptor169 =null; 6477 ParserRuleReturnScope reference_type_descriptor170 =null; 6478 ParserRuleReturnScope member_name172 =null; 6479 ParserRuleReturnScope nonvoid_type_descriptor174 =null; 6480 ParserRuleReturnScope member_name175 =null; 6481 ParserRuleReturnScope method_prototype176 =null; 6482 6483 CommonTree ARROW171_tree=null; 6484 CommonTree COLON173_tree=null; 6485 CommonTree PRIMITIVE_TYPE177_tree=null; 6486 CommonTree VOID_TYPE178_tree=null; 6487 RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON"); 6488 RewriteRuleTokenStream stream_ARROW=new RewriteRuleTokenStream(adaptor,"token ARROW"); 6489 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 6490 RewriteRuleSubtreeStream stream_method_prototype=new RewriteRuleSubtreeStream(adaptor,"rule method_prototype"); 6491 RewriteRuleSubtreeStream stream_reference_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule reference_type_descriptor"); 6492 RewriteRuleSubtreeStream stream_member_name=new RewriteRuleSubtreeStream(adaptor,"rule member_name"); 6493 6494 try { 6495 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:700: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 ) 6496 int alt29=4; 6497 switch ( input.LA(1) ) { 6498 case ARRAY_DESCRIPTOR: 6499 case CLASS_DESCRIPTOR: 6500 { 6501 int LA29_1 = input.LA(2); 6502 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_FORMAT25x)||(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)) ) { 6503 alt29=1; 6504 } 6505 else if ( (LA29_1==ARROW) ) { 6506 alt29=2; 6507 } 6508 6509 else { 6510 int nvaeMark = input.mark(); 6511 try { 6512 input.consume(); 6513 NoViableAltException nvae = 6514 new NoViableAltException("", 29, 1, input); 6515 throw nvae; 6516 } finally { 6517 input.rewind(nvaeMark); 6518 } 6519 } 6520 6521 } 6522 break; 6523 case ACCESS_SPEC: 6524 case ANNOTATION_VISIBILITY: 6525 case BOOL_LITERAL: 6526 case DOUBLE_LITERAL_OR_ID: 6527 case FLOAT_LITERAL_OR_ID: 6528 case INSTRUCTION_FORMAT10t: 6529 case INSTRUCTION_FORMAT10x: 6530 case INSTRUCTION_FORMAT10x_ODEX: 6531 case INSTRUCTION_FORMAT11x: 6532 case INSTRUCTION_FORMAT12x_OR_ID: 6533 case INSTRUCTION_FORMAT21c_FIELD: 6534 case INSTRUCTION_FORMAT21c_FIELD_ODEX: 6535 case INSTRUCTION_FORMAT21c_LAMBDA: 6536 case INSTRUCTION_FORMAT21c_METHOD: 6537 case INSTRUCTION_FORMAT21c_STRING: 6538 case INSTRUCTION_FORMAT21c_TYPE: 6539 case INSTRUCTION_FORMAT21t: 6540 case INSTRUCTION_FORMAT22c_FIELD: 6541 case INSTRUCTION_FORMAT22c_FIELD_ODEX: 6542 case INSTRUCTION_FORMAT22c_STRING: 6543 case INSTRUCTION_FORMAT22c_TYPE: 6544 case INSTRUCTION_FORMAT22cs_FIELD: 6545 case INSTRUCTION_FORMAT22s_OR_ID: 6546 case INSTRUCTION_FORMAT22t: 6547 case INSTRUCTION_FORMAT23x: 6548 case INSTRUCTION_FORMAT25x: 6549 case INSTRUCTION_FORMAT31i_OR_ID: 6550 case INSTRUCTION_FORMAT31t: 6551 case INSTRUCTION_FORMAT35c_METHOD: 6552 case INSTRUCTION_FORMAT35c_METHOD_ODEX: 6553 case INSTRUCTION_FORMAT35c_TYPE: 6554 case INSTRUCTION_FORMAT35mi_METHOD: 6555 case INSTRUCTION_FORMAT35ms_METHOD: 6556 case INSTRUCTION_FORMAT51l: 6557 case MEMBER_NAME: 6558 case NEGATIVE_INTEGER_LITERAL: 6559 case NULL_LITERAL: 6560 case PARAM_LIST_OR_ID_START: 6561 case POSITIVE_INTEGER_LITERAL: 6562 case REGISTER: 6563 case SIMPLE_NAME: 6564 case VERIFICATION_ERROR_TYPE: 6565 { 6566 alt29=2; 6567 } 6568 break; 6569 case PRIMITIVE_TYPE: 6570 { 6571 int LA29_3 = input.LA(2); 6572 if ( (LA29_3==COLON||LA29_3==OPEN_PAREN) ) { 6573 alt29=2; 6574 } 6575 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_FORMAT25x)||(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)) ) { 6576 alt29=3; 6577 } 6578 6579 else { 6580 int nvaeMark = input.mark(); 6581 try { 6582 input.consume(); 6583 NoViableAltException nvae = 6584 new NoViableAltException("", 29, 3, input); 6585 throw nvae; 6586 } finally { 6587 input.rewind(nvaeMark); 6588 } 6589 } 6590 6591 } 6592 break; 6593 case VOID_TYPE: 6594 { 6595 int LA29_4 = input.LA(2); 6596 if ( (LA29_4==COLON||LA29_4==OPEN_PAREN) ) { 6597 alt29=2; 6598 } 6599 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_FORMAT25x)||(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)) ) { 6600 alt29=4; 6601 } 6602 6603 else { 6604 int nvaeMark = input.mark(); 6605 try { 6606 input.consume(); 6607 NoViableAltException nvae = 6608 new NoViableAltException("", 29, 4, input); 6609 throw nvae; 6610 } finally { 6611 input.rewind(nvaeMark); 6612 } 6613 } 6614 6615 } 6616 break; 6617 default: 6618 NoViableAltException nvae = 6619 new NoViableAltException("", 29, 0, input); 6620 throw nvae; 6621 } 6622 switch (alt29) { 6623 case 1 : 6624 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:700:5: reference_type_descriptor 6625 { 6626 root_0 = (CommonTree)adaptor.nil(); 6627 6628 6629 pushFollow(FOLLOW_reference_type_descriptor_in_type_field_method_literal2938); 6630 reference_type_descriptor169=reference_type_descriptor(); 6631 state._fsp--; 6632 6633 adaptor.addChild(root_0, reference_type_descriptor169.getTree()); 6634 6635 } 6636 break; 6637 case 2 : 6638 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:701: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 ) ) ) 6639 { 6640 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:701: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 ) ) ) 6641 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:701: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 ) ) 6642 { 6643 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:701:7: ( reference_type_descriptor ARROW )? 6644 int alt27=2; 6645 int LA27_0 = input.LA(1); 6646 if ( (LA27_0==ARRAY_DESCRIPTOR||LA27_0==CLASS_DESCRIPTOR) ) { 6647 alt27=1; 6648 } 6649 switch (alt27) { 6650 case 1 : 6651 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:701:8: reference_type_descriptor ARROW 6652 { 6653 pushFollow(FOLLOW_reference_type_descriptor_in_type_field_method_literal2947); 6654 reference_type_descriptor170=reference_type_descriptor(); 6655 state._fsp--; 6656 6657 stream_reference_type_descriptor.add(reference_type_descriptor170.getTree()); 6658 ARROW171=(Token)match(input,ARROW,FOLLOW_ARROW_in_type_field_method_literal2949); 6659 stream_ARROW.add(ARROW171); 6660 6661 } 6662 break; 6663 6664 } 6665 6666 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:702: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 ) ) 6667 int alt28=2; 6668 alt28 = dfa28.predict(input); 6669 switch (alt28) { 6670 case 1 : 6671 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:702:9: member_name COLON nonvoid_type_descriptor 6672 { 6673 pushFollow(FOLLOW_member_name_in_type_field_method_literal2961); 6674 member_name172=member_name(); 6675 state._fsp--; 6676 6677 stream_member_name.add(member_name172.getTree()); 6678 COLON173=(Token)match(input,COLON,FOLLOW_COLON_in_type_field_method_literal2963); 6679 stream_COLON.add(COLON173); 6680 6681 pushFollow(FOLLOW_nonvoid_type_descriptor_in_type_field_method_literal2965); 6682 nonvoid_type_descriptor174=nonvoid_type_descriptor(); 6683 state._fsp--; 6684 6685 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor174.getTree()); 6686 // AST REWRITE 6687 // elements: member_name, nonvoid_type_descriptor, reference_type_descriptor 6688 // token labels: 6689 // rule labels: retval 6690 // token list labels: 6691 // rule list labels: 6692 // wildcard labels: 6693 retval.tree = root_0; 6694 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 6695 6696 root_0 = (CommonTree)adaptor.nil(); 6697 // 702:51: -> ^( I_ENCODED_FIELD ( reference_type_descriptor )? member_name nonvoid_type_descriptor ) 6698 { 6699 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:702:54: ^( I_ENCODED_FIELD ( reference_type_descriptor )? member_name nonvoid_type_descriptor ) 6700 { 6701 CommonTree root_1 = (CommonTree)adaptor.nil(); 6702 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ENCODED_FIELD, "I_ENCODED_FIELD"), root_1); 6703 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:702:72: ( reference_type_descriptor )? 6704 if ( stream_reference_type_descriptor.hasNext() ) { 6705 adaptor.addChild(root_1, stream_reference_type_descriptor.nextTree()); 6706 } 6707 stream_reference_type_descriptor.reset(); 6708 6709 adaptor.addChild(root_1, stream_member_name.nextTree()); 6710 adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree()); 6711 adaptor.addChild(root_0, root_1); 6712 } 6713 6714 } 6715 6716 6717 retval.tree = root_0; 6718 6719 } 6720 break; 6721 case 2 : 6722 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:703:9: member_name method_prototype 6723 { 6724 pushFollow(FOLLOW_member_name_in_type_field_method_literal2988); 6725 member_name175=member_name(); 6726 state._fsp--; 6727 6728 stream_member_name.add(member_name175.getTree()); 6729 pushFollow(FOLLOW_method_prototype_in_type_field_method_literal2990); 6730 method_prototype176=method_prototype(); 6731 state._fsp--; 6732 6733 stream_method_prototype.add(method_prototype176.getTree()); 6734 // AST REWRITE 6735 // elements: reference_type_descriptor, method_prototype, member_name 6736 // token labels: 6737 // rule labels: retval 6738 // token list labels: 6739 // rule list labels: 6740 // wildcard labels: 6741 retval.tree = root_0; 6742 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 6743 6744 root_0 = (CommonTree)adaptor.nil(); 6745 // 703:38: -> ^( I_ENCODED_METHOD ( reference_type_descriptor )? member_name method_prototype ) 6746 { 6747 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:703:41: ^( I_ENCODED_METHOD ( reference_type_descriptor )? member_name method_prototype ) 6748 { 6749 CommonTree root_1 = (CommonTree)adaptor.nil(); 6750 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ENCODED_METHOD, "I_ENCODED_METHOD"), root_1); 6751 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:703:60: ( reference_type_descriptor )? 6752 if ( stream_reference_type_descriptor.hasNext() ) { 6753 adaptor.addChild(root_1, stream_reference_type_descriptor.nextTree()); 6754 } 6755 stream_reference_type_descriptor.reset(); 6756 6757 adaptor.addChild(root_1, stream_member_name.nextTree()); 6758 adaptor.addChild(root_1, stream_method_prototype.nextTree()); 6759 adaptor.addChild(root_0, root_1); 6760 } 6761 6762 } 6763 6764 6765 retval.tree = root_0; 6766 6767 } 6768 break; 6769 6770 } 6771 6772 } 6773 6774 } 6775 break; 6776 case 3 : 6777 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:706:5: PRIMITIVE_TYPE 6778 { 6779 root_0 = (CommonTree)adaptor.nil(); 6780 6781 6782 PRIMITIVE_TYPE177=(Token)match(input,PRIMITIVE_TYPE,FOLLOW_PRIMITIVE_TYPE_in_type_field_method_literal3023); 6783 PRIMITIVE_TYPE177_tree = (CommonTree)adaptor.create(PRIMITIVE_TYPE177); 6784 adaptor.addChild(root_0, PRIMITIVE_TYPE177_tree); 6785 6786 } 6787 break; 6788 case 4 : 6789 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:707:5: VOID_TYPE 6790 { 6791 root_0 = (CommonTree)adaptor.nil(); 6792 6793 6794 VOID_TYPE178=(Token)match(input,VOID_TYPE,FOLLOW_VOID_TYPE_in_type_field_method_literal3029); 6795 VOID_TYPE178_tree = (CommonTree)adaptor.create(VOID_TYPE178); 6796 adaptor.addChild(root_0, VOID_TYPE178_tree); 6797 6798 } 6799 break; 6800 6801 } 6802 retval.stop = input.LT(-1); 6803 6804 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 6805 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 6806 6807 } 6808 catch (RecognitionException re) { 6809 reportError(re); 6810 recover(input,re); 6811 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 6812 } 6813 finally { 6814 // do for sure before leaving 6815 } 6816 return retval; 6817 } 6818 // $ANTLR end "type_field_method_literal" 6819 6820 6821 public static class method_reference_return extends ParserRuleReturnScope { 6822 CommonTree tree; 6823 @Override getTree()6824 public CommonTree getTree() { return tree; } 6825 }; 6826 6827 6828 // $ANTLR start "method_reference" 6829 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:709:1: method_reference : ( reference_type_descriptor ARROW )? member_name method_prototype -> ( reference_type_descriptor )? member_name method_prototype ; method_reference()6830 public final smaliParser.method_reference_return method_reference() throws RecognitionException { 6831 smaliParser.method_reference_return retval = new smaliParser.method_reference_return(); 6832 retval.start = input.LT(1); 6833 6834 CommonTree root_0 = null; 6835 6836 Token ARROW180=null; 6837 ParserRuleReturnScope reference_type_descriptor179 =null; 6838 ParserRuleReturnScope member_name181 =null; 6839 ParserRuleReturnScope method_prototype182 =null; 6840 6841 CommonTree ARROW180_tree=null; 6842 RewriteRuleTokenStream stream_ARROW=new RewriteRuleTokenStream(adaptor,"token ARROW"); 6843 RewriteRuleSubtreeStream stream_method_prototype=new RewriteRuleSubtreeStream(adaptor,"rule method_prototype"); 6844 RewriteRuleSubtreeStream stream_reference_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule reference_type_descriptor"); 6845 RewriteRuleSubtreeStream stream_member_name=new RewriteRuleSubtreeStream(adaptor,"rule member_name"); 6846 6847 try { 6848 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:710:3: ( ( reference_type_descriptor ARROW )? member_name method_prototype -> ( reference_type_descriptor )? member_name method_prototype ) 6849 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:710:5: ( reference_type_descriptor ARROW )? member_name method_prototype 6850 { 6851 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:710:5: ( reference_type_descriptor ARROW )? 6852 int alt30=2; 6853 int LA30_0 = input.LA(1); 6854 if ( (LA30_0==ARRAY_DESCRIPTOR||LA30_0==CLASS_DESCRIPTOR) ) { 6855 alt30=1; 6856 } 6857 switch (alt30) { 6858 case 1 : 6859 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:710:6: reference_type_descriptor ARROW 6860 { 6861 pushFollow(FOLLOW_reference_type_descriptor_in_method_reference3040); 6862 reference_type_descriptor179=reference_type_descriptor(); 6863 state._fsp--; 6864 6865 stream_reference_type_descriptor.add(reference_type_descriptor179.getTree()); 6866 ARROW180=(Token)match(input,ARROW,FOLLOW_ARROW_in_method_reference3042); 6867 stream_ARROW.add(ARROW180); 6868 6869 } 6870 break; 6871 6872 } 6873 6874 pushFollow(FOLLOW_member_name_in_method_reference3046); 6875 member_name181=member_name(); 6876 state._fsp--; 6877 6878 stream_member_name.add(member_name181.getTree()); 6879 pushFollow(FOLLOW_method_prototype_in_method_reference3048); 6880 method_prototype182=method_prototype(); 6881 state._fsp--; 6882 6883 stream_method_prototype.add(method_prototype182.getTree()); 6884 // AST REWRITE 6885 // elements: method_prototype, reference_type_descriptor, member_name 6886 // token labels: 6887 // rule labels: retval 6888 // token list labels: 6889 // rule list labels: 6890 // wildcard labels: 6891 retval.tree = root_0; 6892 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 6893 6894 root_0 = (CommonTree)adaptor.nil(); 6895 // 711:3: -> ( reference_type_descriptor )? member_name method_prototype 6896 { 6897 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:711:6: ( reference_type_descriptor )? 6898 if ( stream_reference_type_descriptor.hasNext() ) { 6899 adaptor.addChild(root_0, stream_reference_type_descriptor.nextTree()); 6900 } 6901 stream_reference_type_descriptor.reset(); 6902 6903 adaptor.addChild(root_0, stream_member_name.nextTree()); 6904 adaptor.addChild(root_0, stream_method_prototype.nextTree()); 6905 } 6906 6907 6908 retval.tree = root_0; 6909 6910 } 6911 6912 retval.stop = input.LT(-1); 6913 6914 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 6915 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 6916 6917 } 6918 catch (RecognitionException re) { 6919 reportError(re); 6920 recover(input,re); 6921 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 6922 } 6923 finally { 6924 // do for sure before leaving 6925 } 6926 return retval; 6927 } 6928 // $ANTLR end "method_reference" 6929 6930 6931 public static class field_reference_return extends ParserRuleReturnScope { 6932 CommonTree tree; 6933 @Override getTree()6934 public CommonTree getTree() { return tree; } 6935 }; 6936 6937 6938 // $ANTLR start "field_reference" 6939 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:713:1: field_reference : ( reference_type_descriptor ARROW )? member_name COLON nonvoid_type_descriptor -> ( reference_type_descriptor )? member_name nonvoid_type_descriptor ; field_reference()6940 public final smaliParser.field_reference_return field_reference() throws RecognitionException { 6941 smaliParser.field_reference_return retval = new smaliParser.field_reference_return(); 6942 retval.start = input.LT(1); 6943 6944 CommonTree root_0 = null; 6945 6946 Token ARROW184=null; 6947 Token COLON186=null; 6948 ParserRuleReturnScope reference_type_descriptor183 =null; 6949 ParserRuleReturnScope member_name185 =null; 6950 ParserRuleReturnScope nonvoid_type_descriptor187 =null; 6951 6952 CommonTree ARROW184_tree=null; 6953 CommonTree COLON186_tree=null; 6954 RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON"); 6955 RewriteRuleTokenStream stream_ARROW=new RewriteRuleTokenStream(adaptor,"token ARROW"); 6956 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 6957 RewriteRuleSubtreeStream stream_reference_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule reference_type_descriptor"); 6958 RewriteRuleSubtreeStream stream_member_name=new RewriteRuleSubtreeStream(adaptor,"rule member_name"); 6959 6960 try { 6961 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:714:3: ( ( reference_type_descriptor ARROW )? member_name COLON nonvoid_type_descriptor -> ( reference_type_descriptor )? member_name nonvoid_type_descriptor ) 6962 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:714:5: ( reference_type_descriptor ARROW )? member_name COLON nonvoid_type_descriptor 6963 { 6964 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:714:5: ( reference_type_descriptor ARROW )? 6965 int alt31=2; 6966 int LA31_0 = input.LA(1); 6967 if ( (LA31_0==ARRAY_DESCRIPTOR||LA31_0==CLASS_DESCRIPTOR) ) { 6968 alt31=1; 6969 } 6970 switch (alt31) { 6971 case 1 : 6972 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:714:6: reference_type_descriptor ARROW 6973 { 6974 pushFollow(FOLLOW_reference_type_descriptor_in_field_reference3070); 6975 reference_type_descriptor183=reference_type_descriptor(); 6976 state._fsp--; 6977 6978 stream_reference_type_descriptor.add(reference_type_descriptor183.getTree()); 6979 ARROW184=(Token)match(input,ARROW,FOLLOW_ARROW_in_field_reference3072); 6980 stream_ARROW.add(ARROW184); 6981 6982 } 6983 break; 6984 6985 } 6986 6987 pushFollow(FOLLOW_member_name_in_field_reference3076); 6988 member_name185=member_name(); 6989 state._fsp--; 6990 6991 stream_member_name.add(member_name185.getTree()); 6992 COLON186=(Token)match(input,COLON,FOLLOW_COLON_in_field_reference3078); 6993 stream_COLON.add(COLON186); 6994 6995 pushFollow(FOLLOW_nonvoid_type_descriptor_in_field_reference3080); 6996 nonvoid_type_descriptor187=nonvoid_type_descriptor(); 6997 state._fsp--; 6998 6999 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor187.getTree()); 7000 // AST REWRITE 7001 // elements: member_name, reference_type_descriptor, nonvoid_type_descriptor 7002 // token labels: 7003 // rule labels: retval 7004 // token list labels: 7005 // rule list labels: 7006 // wildcard labels: 7007 retval.tree = root_0; 7008 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7009 7010 root_0 = (CommonTree)adaptor.nil(); 7011 // 715:3: -> ( reference_type_descriptor )? member_name nonvoid_type_descriptor 7012 { 7013 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:715:6: ( reference_type_descriptor )? 7014 if ( stream_reference_type_descriptor.hasNext() ) { 7015 adaptor.addChild(root_0, stream_reference_type_descriptor.nextTree()); 7016 } 7017 stream_reference_type_descriptor.reset(); 7018 7019 adaptor.addChild(root_0, stream_member_name.nextTree()); 7020 adaptor.addChild(root_0, stream_nonvoid_type_descriptor.nextTree()); 7021 } 7022 7023 7024 retval.tree = root_0; 7025 7026 } 7027 7028 retval.stop = input.LT(-1); 7029 7030 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 7031 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 7032 7033 } 7034 catch (RecognitionException re) { 7035 reportError(re); 7036 recover(input,re); 7037 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7038 } 7039 finally { 7040 // do for sure before leaving 7041 } 7042 return retval; 7043 } 7044 // $ANTLR end "field_reference" 7045 7046 7047 public static class label_return extends ParserRuleReturnScope { 7048 CommonTree tree; 7049 @Override getTree()7050 public CommonTree getTree() { return tree; } 7051 }; 7052 7053 7054 // $ANTLR start "label" 7055 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:717:1: label : COLON simple_name -> ^( I_LABEL[$COLON, \"I_LABEL\"] simple_name ) ; label()7056 public final smaliParser.label_return label() throws RecognitionException { 7057 smaliParser.label_return retval = new smaliParser.label_return(); 7058 retval.start = input.LT(1); 7059 7060 CommonTree root_0 = null; 7061 7062 Token COLON188=null; 7063 ParserRuleReturnScope simple_name189 =null; 7064 7065 CommonTree COLON188_tree=null; 7066 RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON"); 7067 RewriteRuleSubtreeStream stream_simple_name=new RewriteRuleSubtreeStream(adaptor,"rule simple_name"); 7068 7069 try { 7070 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:718:3: ( COLON simple_name -> ^( I_LABEL[$COLON, \"I_LABEL\"] simple_name ) ) 7071 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:718:5: COLON simple_name 7072 { 7073 COLON188=(Token)match(input,COLON,FOLLOW_COLON_in_label3101); 7074 stream_COLON.add(COLON188); 7075 7076 pushFollow(FOLLOW_simple_name_in_label3103); 7077 simple_name189=simple_name(); 7078 state._fsp--; 7079 7080 stream_simple_name.add(simple_name189.getTree()); 7081 // AST REWRITE 7082 // elements: simple_name 7083 // token labels: 7084 // rule labels: retval 7085 // token list labels: 7086 // rule list labels: 7087 // wildcard labels: 7088 retval.tree = root_0; 7089 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7090 7091 root_0 = (CommonTree)adaptor.nil(); 7092 // 718:23: -> ^( I_LABEL[$COLON, \"I_LABEL\"] simple_name ) 7093 { 7094 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:718:26: ^( I_LABEL[$COLON, \"I_LABEL\"] simple_name ) 7095 { 7096 CommonTree root_1 = (CommonTree)adaptor.nil(); 7097 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_LABEL, COLON188, "I_LABEL"), root_1); 7098 adaptor.addChild(root_1, stream_simple_name.nextTree()); 7099 adaptor.addChild(root_0, root_1); 7100 } 7101 7102 } 7103 7104 7105 retval.tree = root_0; 7106 7107 } 7108 7109 retval.stop = input.LT(-1); 7110 7111 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 7112 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 7113 7114 } 7115 catch (RecognitionException re) { 7116 reportError(re); 7117 recover(input,re); 7118 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7119 } 7120 finally { 7121 // do for sure before leaving 7122 } 7123 return retval; 7124 } 7125 // $ANTLR end "label" 7126 7127 7128 public static class label_ref_return extends ParserRuleReturnScope { 7129 CommonTree tree; 7130 @Override getTree()7131 public CommonTree getTree() { return tree; } 7132 }; 7133 7134 7135 // $ANTLR start "label_ref" 7136 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:720:1: label_ref : COLON simple_name -> simple_name ; label_ref()7137 public final smaliParser.label_ref_return label_ref() throws RecognitionException { 7138 smaliParser.label_ref_return retval = new smaliParser.label_ref_return(); 7139 retval.start = input.LT(1); 7140 7141 CommonTree root_0 = null; 7142 7143 Token COLON190=null; 7144 ParserRuleReturnScope simple_name191 =null; 7145 7146 CommonTree COLON190_tree=null; 7147 RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON"); 7148 RewriteRuleSubtreeStream stream_simple_name=new RewriteRuleSubtreeStream(adaptor,"rule simple_name"); 7149 7150 try { 7151 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:721:3: ( COLON simple_name -> simple_name ) 7152 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:721:5: COLON simple_name 7153 { 7154 COLON190=(Token)match(input,COLON,FOLLOW_COLON_in_label_ref3122); 7155 stream_COLON.add(COLON190); 7156 7157 pushFollow(FOLLOW_simple_name_in_label_ref3124); 7158 simple_name191=simple_name(); 7159 state._fsp--; 7160 7161 stream_simple_name.add(simple_name191.getTree()); 7162 // AST REWRITE 7163 // elements: simple_name 7164 // token labels: 7165 // rule labels: retval 7166 // token list labels: 7167 // rule list labels: 7168 // wildcard labels: 7169 retval.tree = root_0; 7170 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7171 7172 root_0 = (CommonTree)adaptor.nil(); 7173 // 721:23: -> simple_name 7174 { 7175 adaptor.addChild(root_0, stream_simple_name.nextTree()); 7176 } 7177 7178 7179 retval.tree = root_0; 7180 7181 } 7182 7183 retval.stop = input.LT(-1); 7184 7185 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 7186 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 7187 7188 } 7189 catch (RecognitionException re) { 7190 reportError(re); 7191 recover(input,re); 7192 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7193 } 7194 finally { 7195 // do for sure before leaving 7196 } 7197 return retval; 7198 } 7199 // $ANTLR end "label_ref" 7200 7201 7202 public static class register_list_return extends ParserRuleReturnScope { 7203 CommonTree tree; 7204 @Override getTree()7205 public CommonTree getTree() { return tree; } 7206 }; 7207 7208 7209 // $ANTLR start "register_list" 7210 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:723:1: register_list : ( REGISTER ( COMMA REGISTER )* -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ( REGISTER )* ) | -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ) ); register_list()7211 public final smaliParser.register_list_return register_list() throws RecognitionException { 7212 smaliParser.register_list_return retval = new smaliParser.register_list_return(); 7213 retval.start = input.LT(1); 7214 7215 CommonTree root_0 = null; 7216 7217 Token REGISTER192=null; 7218 Token COMMA193=null; 7219 Token REGISTER194=null; 7220 7221 CommonTree REGISTER192_tree=null; 7222 CommonTree COMMA193_tree=null; 7223 CommonTree REGISTER194_tree=null; 7224 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 7225 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 7226 7227 try { 7228 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:724:3: ( REGISTER ( COMMA REGISTER )* -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ( REGISTER )* ) | -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ) ) 7229 int alt33=2; 7230 int LA33_0 = input.LA(1); 7231 if ( (LA33_0==REGISTER) ) { 7232 alt33=1; 7233 } 7234 else if ( (LA33_0==CLOSE_BRACE) ) { 7235 alt33=2; 7236 } 7237 7238 else { 7239 NoViableAltException nvae = 7240 new NoViableAltException("", 33, 0, input); 7241 throw nvae; 7242 } 7243 7244 switch (alt33) { 7245 case 1 : 7246 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:724:5: REGISTER ( COMMA REGISTER )* 7247 { 7248 REGISTER192=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_register_list3138); 7249 stream_REGISTER.add(REGISTER192); 7250 7251 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:724:14: ( COMMA REGISTER )* 7252 loop32: 7253 while (true) { 7254 int alt32=2; 7255 int LA32_0 = input.LA(1); 7256 if ( (LA32_0==COMMA) ) { 7257 alt32=1; 7258 } 7259 7260 switch (alt32) { 7261 case 1 : 7262 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:724:15: COMMA REGISTER 7263 { 7264 COMMA193=(Token)match(input,COMMA,FOLLOW_COMMA_in_register_list3141); 7265 stream_COMMA.add(COMMA193); 7266 7267 REGISTER194=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_register_list3143); 7268 stream_REGISTER.add(REGISTER194); 7269 7270 } 7271 break; 7272 7273 default : 7274 break loop32; 7275 } 7276 } 7277 7278 // AST REWRITE 7279 // elements: REGISTER 7280 // token labels: 7281 // rule labels: retval 7282 // token list labels: 7283 // rule list labels: 7284 // wildcard labels: 7285 retval.tree = root_0; 7286 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7287 7288 root_0 = (CommonTree)adaptor.nil(); 7289 // 724:32: -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ( REGISTER )* ) 7290 { 7291 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:724:35: ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ( REGISTER )* ) 7292 { 7293 CommonTree root_1 = (CommonTree)adaptor.nil(); 7294 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_REGISTER_LIST, (retval.start), "I_REGISTER_LIST"), root_1); 7295 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:724:80: ( REGISTER )* 7296 while ( stream_REGISTER.hasNext() ) { 7297 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 7298 } 7299 stream_REGISTER.reset(); 7300 7301 adaptor.addChild(root_0, root_1); 7302 } 7303 7304 } 7305 7306 7307 retval.tree = root_0; 7308 7309 } 7310 break; 7311 case 2 : 7312 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:725:5: 7313 { 7314 // AST REWRITE 7315 // elements: 7316 // token labels: 7317 // rule labels: retval 7318 // token list labels: 7319 // rule list labels: 7320 // wildcard labels: 7321 retval.tree = root_0; 7322 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7323 7324 root_0 = (CommonTree)adaptor.nil(); 7325 // 725:5: -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ) 7326 { 7327 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:725:7: ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ) 7328 { 7329 CommonTree root_1 = (CommonTree)adaptor.nil(); 7330 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_REGISTER_LIST, (retval.start), "I_REGISTER_LIST"), root_1); 7331 adaptor.addChild(root_0, root_1); 7332 } 7333 7334 } 7335 7336 7337 retval.tree = root_0; 7338 7339 } 7340 break; 7341 7342 } 7343 retval.stop = input.LT(-1); 7344 7345 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 7346 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 7347 7348 } 7349 catch (RecognitionException re) { 7350 reportError(re); 7351 recover(input,re); 7352 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7353 } 7354 finally { 7355 // do for sure before leaving 7356 } 7357 return retval; 7358 } 7359 // $ANTLR end "register_list" 7360 7361 7362 public static class register_range_return extends ParserRuleReturnScope { 7363 CommonTree tree; 7364 @Override getTree()7365 public CommonTree getTree() { return tree; } 7366 }; 7367 7368 7369 // $ANTLR start "register_range" 7370 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:727:1: register_range : (startreg= REGISTER ( DOTDOT endreg= REGISTER )? )? -> ^( I_REGISTER_RANGE[$start, \"I_REGISTER_RANGE\"] ( $startreg)? ( $endreg)? ) ; register_range()7371 public final smaliParser.register_range_return register_range() throws RecognitionException { 7372 smaliParser.register_range_return retval = new smaliParser.register_range_return(); 7373 retval.start = input.LT(1); 7374 7375 CommonTree root_0 = null; 7376 7377 Token startreg=null; 7378 Token endreg=null; 7379 Token DOTDOT195=null; 7380 7381 CommonTree startreg_tree=null; 7382 CommonTree endreg_tree=null; 7383 CommonTree DOTDOT195_tree=null; 7384 RewriteRuleTokenStream stream_DOTDOT=new RewriteRuleTokenStream(adaptor,"token DOTDOT"); 7385 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 7386 7387 try { 7388 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:728:3: ( (startreg= REGISTER ( DOTDOT endreg= REGISTER )? )? -> ^( I_REGISTER_RANGE[$start, \"I_REGISTER_RANGE\"] ( $startreg)? ( $endreg)? ) ) 7389 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:728:5: (startreg= REGISTER ( DOTDOT endreg= REGISTER )? )? 7390 { 7391 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:728:5: (startreg= REGISTER ( DOTDOT endreg= REGISTER )? )? 7392 int alt35=2; 7393 int LA35_0 = input.LA(1); 7394 if ( (LA35_0==REGISTER) ) { 7395 alt35=1; 7396 } 7397 switch (alt35) { 7398 case 1 : 7399 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:728:6: startreg= REGISTER ( DOTDOT endreg= REGISTER )? 7400 { 7401 startreg=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_register_range3178); 7402 stream_REGISTER.add(startreg); 7403 7404 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:728:24: ( DOTDOT endreg= REGISTER )? 7405 int alt34=2; 7406 int LA34_0 = input.LA(1); 7407 if ( (LA34_0==DOTDOT) ) { 7408 alt34=1; 7409 } 7410 switch (alt34) { 7411 case 1 : 7412 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:728:25: DOTDOT endreg= REGISTER 7413 { 7414 DOTDOT195=(Token)match(input,DOTDOT,FOLLOW_DOTDOT_in_register_range3181); 7415 stream_DOTDOT.add(DOTDOT195); 7416 7417 endreg=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_register_range3185); 7418 stream_REGISTER.add(endreg); 7419 7420 } 7421 break; 7422 7423 } 7424 7425 } 7426 break; 7427 7428 } 7429 7430 // AST REWRITE 7431 // elements: endreg, startreg 7432 // token labels: endreg, startreg 7433 // rule labels: retval 7434 // token list labels: 7435 // rule list labels: 7436 // wildcard labels: 7437 retval.tree = root_0; 7438 RewriteRuleTokenStream stream_endreg=new RewriteRuleTokenStream(adaptor,"token endreg",endreg); 7439 RewriteRuleTokenStream stream_startreg=new RewriteRuleTokenStream(adaptor,"token startreg",startreg); 7440 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7441 7442 root_0 = (CommonTree)adaptor.nil(); 7443 // 728:52: -> ^( I_REGISTER_RANGE[$start, \"I_REGISTER_RANGE\"] ( $startreg)? ( $endreg)? ) 7444 { 7445 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:728:55: ^( I_REGISTER_RANGE[$start, \"I_REGISTER_RANGE\"] ( $startreg)? ( $endreg)? ) 7446 { 7447 CommonTree root_1 = (CommonTree)adaptor.nil(); 7448 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_REGISTER_RANGE, (retval.start), "I_REGISTER_RANGE"), root_1); 7449 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:728:103: ( $startreg)? 7450 if ( stream_startreg.hasNext() ) { 7451 adaptor.addChild(root_1, stream_startreg.nextNode()); 7452 } 7453 stream_startreg.reset(); 7454 7455 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:728:114: ( $endreg)? 7456 if ( stream_endreg.hasNext() ) { 7457 adaptor.addChild(root_1, stream_endreg.nextNode()); 7458 } 7459 stream_endreg.reset(); 7460 7461 adaptor.addChild(root_0, root_1); 7462 } 7463 7464 } 7465 7466 7467 retval.tree = root_0; 7468 7469 } 7470 7471 retval.stop = input.LT(-1); 7472 7473 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 7474 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 7475 7476 } 7477 catch (RecognitionException re) { 7478 reportError(re); 7479 recover(input,re); 7480 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7481 } 7482 finally { 7483 // do for sure before leaving 7484 } 7485 return retval; 7486 } 7487 // $ANTLR end "register_range" 7488 7489 7490 public static class verification_error_reference_return extends ParserRuleReturnScope { 7491 CommonTree tree; 7492 @Override getTree()7493 public CommonTree getTree() { return tree; } 7494 }; 7495 7496 7497 // $ANTLR start "verification_error_reference" 7498 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:730:1: verification_error_reference : ( CLASS_DESCRIPTOR | field_reference | method_reference ); verification_error_reference()7499 public final smaliParser.verification_error_reference_return verification_error_reference() throws RecognitionException { 7500 smaliParser.verification_error_reference_return retval = new smaliParser.verification_error_reference_return(); 7501 retval.start = input.LT(1); 7502 7503 CommonTree root_0 = null; 7504 7505 Token CLASS_DESCRIPTOR196=null; 7506 ParserRuleReturnScope field_reference197 =null; 7507 ParserRuleReturnScope method_reference198 =null; 7508 7509 CommonTree CLASS_DESCRIPTOR196_tree=null; 7510 7511 try { 7512 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:731:3: ( CLASS_DESCRIPTOR | field_reference | method_reference ) 7513 int alt36=3; 7514 alt36 = dfa36.predict(input); 7515 switch (alt36) { 7516 case 1 : 7517 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:731:5: CLASS_DESCRIPTOR 7518 { 7519 root_0 = (CommonTree)adaptor.nil(); 7520 7521 7522 CLASS_DESCRIPTOR196=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_verification_error_reference3214); 7523 CLASS_DESCRIPTOR196_tree = (CommonTree)adaptor.create(CLASS_DESCRIPTOR196); 7524 adaptor.addChild(root_0, CLASS_DESCRIPTOR196_tree); 7525 7526 } 7527 break; 7528 case 2 : 7529 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:731:24: field_reference 7530 { 7531 root_0 = (CommonTree)adaptor.nil(); 7532 7533 7534 pushFollow(FOLLOW_field_reference_in_verification_error_reference3218); 7535 field_reference197=field_reference(); 7536 state._fsp--; 7537 7538 adaptor.addChild(root_0, field_reference197.getTree()); 7539 7540 } 7541 break; 7542 case 3 : 7543 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:731:42: method_reference 7544 { 7545 root_0 = (CommonTree)adaptor.nil(); 7546 7547 7548 pushFollow(FOLLOW_method_reference_in_verification_error_reference3222); 7549 method_reference198=method_reference(); 7550 state._fsp--; 7551 7552 adaptor.addChild(root_0, method_reference198.getTree()); 7553 7554 } 7555 break; 7556 7557 } 7558 retval.stop = input.LT(-1); 7559 7560 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 7561 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 7562 7563 } 7564 catch (RecognitionException re) { 7565 reportError(re); 7566 recover(input,re); 7567 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7568 } 7569 finally { 7570 // do for sure before leaving 7571 } 7572 return retval; 7573 } 7574 // $ANTLR end "verification_error_reference" 7575 7576 7577 public static class catch_directive_return extends ParserRuleReturnScope { 7578 CommonTree tree; 7579 @Override getTree()7580 public CommonTree getTree() { return tree; } 7581 }; 7582 7583 7584 // $ANTLR start "catch_directive" 7585 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:733: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) ; catch_directive()7586 public final smaliParser.catch_directive_return catch_directive() throws RecognitionException { 7587 smaliParser.catch_directive_return retval = new smaliParser.catch_directive_return(); 7588 retval.start = input.LT(1); 7589 7590 CommonTree root_0 = null; 7591 7592 Token CATCH_DIRECTIVE199=null; 7593 Token OPEN_BRACE201=null; 7594 Token DOTDOT202=null; 7595 Token CLOSE_BRACE203=null; 7596 ParserRuleReturnScope from =null; 7597 ParserRuleReturnScope to =null; 7598 ParserRuleReturnScope using =null; 7599 ParserRuleReturnScope nonvoid_type_descriptor200 =null; 7600 7601 CommonTree CATCH_DIRECTIVE199_tree=null; 7602 CommonTree OPEN_BRACE201_tree=null; 7603 CommonTree DOTDOT202_tree=null; 7604 CommonTree CLOSE_BRACE203_tree=null; 7605 RewriteRuleTokenStream stream_DOTDOT=new RewriteRuleTokenStream(adaptor,"token DOTDOT"); 7606 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 7607 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 7608 RewriteRuleTokenStream stream_CATCH_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token CATCH_DIRECTIVE"); 7609 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 7610 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 7611 7612 try { 7613 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:734: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) ) 7614 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:734:5: CATCH_DIRECTIVE nonvoid_type_descriptor OPEN_BRACE from= label_ref DOTDOT to= label_ref CLOSE_BRACE using= label_ref 7615 { 7616 CATCH_DIRECTIVE199=(Token)match(input,CATCH_DIRECTIVE,FOLLOW_CATCH_DIRECTIVE_in_catch_directive3232); 7617 stream_CATCH_DIRECTIVE.add(CATCH_DIRECTIVE199); 7618 7619 pushFollow(FOLLOW_nonvoid_type_descriptor_in_catch_directive3234); 7620 nonvoid_type_descriptor200=nonvoid_type_descriptor(); 7621 state._fsp--; 7622 7623 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor200.getTree()); 7624 OPEN_BRACE201=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_catch_directive3236); 7625 stream_OPEN_BRACE.add(OPEN_BRACE201); 7626 7627 pushFollow(FOLLOW_label_ref_in_catch_directive3240); 7628 from=label_ref(); 7629 state._fsp--; 7630 7631 stream_label_ref.add(from.getTree()); 7632 DOTDOT202=(Token)match(input,DOTDOT,FOLLOW_DOTDOT_in_catch_directive3242); 7633 stream_DOTDOT.add(DOTDOT202); 7634 7635 pushFollow(FOLLOW_label_ref_in_catch_directive3246); 7636 to=label_ref(); 7637 state._fsp--; 7638 7639 stream_label_ref.add(to.getTree()); 7640 CLOSE_BRACE203=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_catch_directive3248); 7641 stream_CLOSE_BRACE.add(CLOSE_BRACE203); 7642 7643 pushFollow(FOLLOW_label_ref_in_catch_directive3252); 7644 using=label_ref(); 7645 state._fsp--; 7646 7647 stream_label_ref.add(using.getTree()); 7648 // AST REWRITE 7649 // elements: from, using, nonvoid_type_descriptor, to 7650 // token labels: 7651 // rule labels: to, retval, using, from 7652 // token list labels: 7653 // rule list labels: 7654 // wildcard labels: 7655 retval.tree = root_0; 7656 RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.getTree():null); 7657 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7658 RewriteRuleSubtreeStream stream_using=new RewriteRuleSubtreeStream(adaptor,"rule using",using!=null?using.getTree():null); 7659 RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.getTree():null); 7660 7661 root_0 = (CommonTree)adaptor.nil(); 7662 // 735:5: -> ^( I_CATCH[$start, \"I_CATCH\"] nonvoid_type_descriptor $from $to $using) 7663 { 7664 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:735:8: ^( I_CATCH[$start, \"I_CATCH\"] nonvoid_type_descriptor $from $to $using) 7665 { 7666 CommonTree root_1 = (CommonTree)adaptor.nil(); 7667 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_CATCH, (retval.start), "I_CATCH"), root_1); 7668 adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree()); 7669 adaptor.addChild(root_1, stream_from.nextTree()); 7670 adaptor.addChild(root_1, stream_to.nextTree()); 7671 adaptor.addChild(root_1, stream_using.nextTree()); 7672 adaptor.addChild(root_0, root_1); 7673 } 7674 7675 } 7676 7677 7678 retval.tree = root_0; 7679 7680 } 7681 7682 retval.stop = input.LT(-1); 7683 7684 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 7685 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 7686 7687 } 7688 catch (RecognitionException re) { 7689 reportError(re); 7690 recover(input,re); 7691 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7692 } 7693 finally { 7694 // do for sure before leaving 7695 } 7696 return retval; 7697 } 7698 // $ANTLR end "catch_directive" 7699 7700 7701 public static class catchall_directive_return extends ParserRuleReturnScope { 7702 CommonTree tree; 7703 @Override getTree()7704 public CommonTree getTree() { return tree; } 7705 }; 7706 7707 7708 // $ANTLR start "catchall_directive" 7709 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:737: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) ; catchall_directive()7710 public final smaliParser.catchall_directive_return catchall_directive() throws RecognitionException { 7711 smaliParser.catchall_directive_return retval = new smaliParser.catchall_directive_return(); 7712 retval.start = input.LT(1); 7713 7714 CommonTree root_0 = null; 7715 7716 Token CATCHALL_DIRECTIVE204=null; 7717 Token OPEN_BRACE205=null; 7718 Token DOTDOT206=null; 7719 Token CLOSE_BRACE207=null; 7720 ParserRuleReturnScope from =null; 7721 ParserRuleReturnScope to =null; 7722 ParserRuleReturnScope using =null; 7723 7724 CommonTree CATCHALL_DIRECTIVE204_tree=null; 7725 CommonTree OPEN_BRACE205_tree=null; 7726 CommonTree DOTDOT206_tree=null; 7727 CommonTree CLOSE_BRACE207_tree=null; 7728 RewriteRuleTokenStream stream_DOTDOT=new RewriteRuleTokenStream(adaptor,"token DOTDOT"); 7729 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 7730 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 7731 RewriteRuleTokenStream stream_CATCHALL_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token CATCHALL_DIRECTIVE"); 7732 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 7733 7734 try { 7735 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:738: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) ) 7736 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:738:5: CATCHALL_DIRECTIVE OPEN_BRACE from= label_ref DOTDOT to= label_ref CLOSE_BRACE using= label_ref 7737 { 7738 CATCHALL_DIRECTIVE204=(Token)match(input,CATCHALL_DIRECTIVE,FOLLOW_CATCHALL_DIRECTIVE_in_catchall_directive3284); 7739 stream_CATCHALL_DIRECTIVE.add(CATCHALL_DIRECTIVE204); 7740 7741 OPEN_BRACE205=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_catchall_directive3286); 7742 stream_OPEN_BRACE.add(OPEN_BRACE205); 7743 7744 pushFollow(FOLLOW_label_ref_in_catchall_directive3290); 7745 from=label_ref(); 7746 state._fsp--; 7747 7748 stream_label_ref.add(from.getTree()); 7749 DOTDOT206=(Token)match(input,DOTDOT,FOLLOW_DOTDOT_in_catchall_directive3292); 7750 stream_DOTDOT.add(DOTDOT206); 7751 7752 pushFollow(FOLLOW_label_ref_in_catchall_directive3296); 7753 to=label_ref(); 7754 state._fsp--; 7755 7756 stream_label_ref.add(to.getTree()); 7757 CLOSE_BRACE207=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_catchall_directive3298); 7758 stream_CLOSE_BRACE.add(CLOSE_BRACE207); 7759 7760 pushFollow(FOLLOW_label_ref_in_catchall_directive3302); 7761 using=label_ref(); 7762 state._fsp--; 7763 7764 stream_label_ref.add(using.getTree()); 7765 // AST REWRITE 7766 // elements: using, to, from 7767 // token labels: 7768 // rule labels: to, retval, using, from 7769 // token list labels: 7770 // rule list labels: 7771 // wildcard labels: 7772 retval.tree = root_0; 7773 RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.getTree():null); 7774 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7775 RewriteRuleSubtreeStream stream_using=new RewriteRuleSubtreeStream(adaptor,"rule using",using!=null?using.getTree():null); 7776 RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.getTree():null); 7777 7778 root_0 = (CommonTree)adaptor.nil(); 7779 // 739:5: -> ^( I_CATCHALL[$start, \"I_CATCHALL\"] $from $to $using) 7780 { 7781 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:739:8: ^( I_CATCHALL[$start, \"I_CATCHALL\"] $from $to $using) 7782 { 7783 CommonTree root_1 = (CommonTree)adaptor.nil(); 7784 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_CATCHALL, (retval.start), "I_CATCHALL"), root_1); 7785 adaptor.addChild(root_1, stream_from.nextTree()); 7786 adaptor.addChild(root_1, stream_to.nextTree()); 7787 adaptor.addChild(root_1, stream_using.nextTree()); 7788 adaptor.addChild(root_0, root_1); 7789 } 7790 7791 } 7792 7793 7794 retval.tree = root_0; 7795 7796 } 7797 7798 retval.stop = input.LT(-1); 7799 7800 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 7801 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 7802 7803 } 7804 catch (RecognitionException re) { 7805 reportError(re); 7806 recover(input,re); 7807 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7808 } 7809 finally { 7810 // do for sure before leaving 7811 } 7812 return retval; 7813 } 7814 // $ANTLR end "catchall_directive" 7815 7816 7817 public static class parameter_directive_return extends ParserRuleReturnScope { 7818 CommonTree tree; 7819 @Override getTree()7820 public CommonTree getTree() { return tree; } 7821 }; 7822 7823 7824 // $ANTLR start "parameter_directive" 7825 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:745: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 ) ) ) ; parameter_directive()7826 public final smaliParser.parameter_directive_return parameter_directive() throws RecognitionException { 7827 smaliParser.parameter_directive_return retval = new smaliParser.parameter_directive_return(); 7828 retval.start = input.LT(1); 7829 7830 CommonTree root_0 = null; 7831 7832 Token PARAMETER_DIRECTIVE208=null; 7833 Token REGISTER209=null; 7834 Token COMMA210=null; 7835 Token STRING_LITERAL211=null; 7836 Token END_PARAMETER_DIRECTIVE213=null; 7837 ParserRuleReturnScope annotation212 =null; 7838 7839 CommonTree PARAMETER_DIRECTIVE208_tree=null; 7840 CommonTree REGISTER209_tree=null; 7841 CommonTree COMMA210_tree=null; 7842 CommonTree STRING_LITERAL211_tree=null; 7843 CommonTree END_PARAMETER_DIRECTIVE213_tree=null; 7844 RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL"); 7845 RewriteRuleTokenStream stream_END_PARAMETER_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_PARAMETER_DIRECTIVE"); 7846 RewriteRuleTokenStream stream_PARAMETER_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token PARAMETER_DIRECTIVE"); 7847 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 7848 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 7849 RewriteRuleSubtreeStream stream_annotation=new RewriteRuleSubtreeStream(adaptor,"rule annotation"); 7850 7851 List<CommonTree> annotations = new ArrayList<CommonTree>(); 7852 try { 7853 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:747: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 ) ) ) ) 7854 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:747: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 ) ) ) 7855 { 7856 PARAMETER_DIRECTIVE208=(Token)match(input,PARAMETER_DIRECTIVE,FOLLOW_PARAMETER_DIRECTIVE_in_parameter_directive3341); 7857 stream_PARAMETER_DIRECTIVE.add(PARAMETER_DIRECTIVE208); 7858 7859 REGISTER209=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_parameter_directive3343); 7860 stream_REGISTER.add(REGISTER209); 7861 7862 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:747:34: ( COMMA STRING_LITERAL )? 7863 int alt37=2; 7864 int LA37_0 = input.LA(1); 7865 if ( (LA37_0==COMMA) ) { 7866 alt37=1; 7867 } 7868 switch (alt37) { 7869 case 1 : 7870 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:747:35: COMMA STRING_LITERAL 7871 { 7872 COMMA210=(Token)match(input,COMMA,FOLLOW_COMMA_in_parameter_directive3346); 7873 stream_COMMA.add(COMMA210); 7874 7875 STRING_LITERAL211=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_parameter_directive3348); 7876 stream_STRING_LITERAL.add(STRING_LITERAL211); 7877 7878 } 7879 break; 7880 7881 } 7882 7883 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:748:5: ({...}? annotation )* 7884 loop38: 7885 while (true) { 7886 int alt38=2; 7887 alt38 = dfa38.predict(input); 7888 switch (alt38) { 7889 case 1 : 7890 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:748:6: {...}? annotation 7891 { 7892 if ( !((input.LA(1) == ANNOTATION_DIRECTIVE)) ) { 7893 throw new FailedPredicateException(input, "parameter_directive", "input.LA(1) == ANNOTATION_DIRECTIVE"); 7894 } 7895 pushFollow(FOLLOW_annotation_in_parameter_directive3359); 7896 annotation212=annotation(); 7897 state._fsp--; 7898 7899 stream_annotation.add(annotation212.getTree()); 7900 annotations.add((annotation212!=null?((CommonTree)annotation212.getTree()):null)); 7901 } 7902 break; 7903 7904 default : 7905 break loop38; 7906 } 7907 } 7908 7909 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:750: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 ) ) ) 7910 int alt39=2; 7911 int LA39_0 = input.LA(1); 7912 if ( (LA39_0==END_PARAMETER_DIRECTIVE) ) { 7913 alt39=1; 7914 } 7915 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)) ) { 7916 alt39=2; 7917 } 7918 7919 else { 7920 NoViableAltException nvae = 7921 new NoViableAltException("", 39, 0, input); 7922 throw nvae; 7923 } 7924 7925 switch (alt39) { 7926 case 1 : 7927 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:750:7: END_PARAMETER_DIRECTIVE 7928 { 7929 END_PARAMETER_DIRECTIVE213=(Token)match(input,END_PARAMETER_DIRECTIVE,FOLLOW_END_PARAMETER_DIRECTIVE_in_parameter_directive3372); 7930 stream_END_PARAMETER_DIRECTIVE.add(END_PARAMETER_DIRECTIVE213); 7931 7932 // AST REWRITE 7933 // elements: STRING_LITERAL, REGISTER, annotation 7934 // token labels: 7935 // rule labels: retval 7936 // token list labels: 7937 // rule list labels: 7938 // wildcard labels: 7939 retval.tree = root_0; 7940 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7941 7942 root_0 = (CommonTree)adaptor.nil(); 7943 // 751:7: -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ( annotation )* ) ) 7944 { 7945 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:751:10: ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ( annotation )* ) ) 7946 { 7947 CommonTree root_1 = (CommonTree)adaptor.nil(); 7948 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_PARAMETER, (retval.start), "I_PARAMETER"), root_1); 7949 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 7950 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:751:56: ( STRING_LITERAL )? 7951 if ( stream_STRING_LITERAL.hasNext() ) { 7952 adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode()); 7953 } 7954 stream_STRING_LITERAL.reset(); 7955 7956 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:751:72: ^( I_ANNOTATIONS ( annotation )* ) 7957 { 7958 CommonTree root_2 = (CommonTree)adaptor.nil(); 7959 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATIONS, "I_ANNOTATIONS"), root_2); 7960 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:751:88: ( annotation )* 7961 while ( stream_annotation.hasNext() ) { 7962 adaptor.addChild(root_2, stream_annotation.nextTree()); 7963 } 7964 stream_annotation.reset(); 7965 7966 adaptor.addChild(root_1, root_2); 7967 } 7968 7969 adaptor.addChild(root_0, root_1); 7970 } 7971 7972 } 7973 7974 7975 retval.tree = root_0; 7976 7977 } 7978 break; 7979 case 2 : 7980 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:752:19: 7981 { 7982 statements_and_directives_stack.peek().methodAnnotations.addAll(annotations); 7983 // AST REWRITE 7984 // elements: STRING_LITERAL, REGISTER 7985 // token labels: 7986 // rule labels: retval 7987 // token list labels: 7988 // rule list labels: 7989 // wildcard labels: 7990 retval.tree = root_0; 7991 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7992 7993 root_0 = (CommonTree)adaptor.nil(); 7994 // 753:7: -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ) ) 7995 { 7996 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:753:10: ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ) ) 7997 { 7998 CommonTree root_1 = (CommonTree)adaptor.nil(); 7999 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_PARAMETER, (retval.start), "I_PARAMETER"), root_1); 8000 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 8001 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:753:56: ( STRING_LITERAL )? 8002 if ( stream_STRING_LITERAL.hasNext() ) { 8003 adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode()); 8004 } 8005 stream_STRING_LITERAL.reset(); 8006 8007 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:753:72: ^( I_ANNOTATIONS ) 8008 { 8009 CommonTree root_2 = (CommonTree)adaptor.nil(); 8010 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATIONS, "I_ANNOTATIONS"), root_2); 8011 adaptor.addChild(root_1, root_2); 8012 } 8013 8014 adaptor.addChild(root_0, root_1); 8015 } 8016 8017 } 8018 8019 8020 retval.tree = root_0; 8021 8022 } 8023 break; 8024 8025 } 8026 8027 } 8028 8029 retval.stop = input.LT(-1); 8030 8031 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8032 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8033 8034 } 8035 catch (RecognitionException re) { 8036 reportError(re); 8037 recover(input,re); 8038 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8039 } 8040 finally { 8041 // do for sure before leaving 8042 } 8043 return retval; 8044 } 8045 // $ANTLR end "parameter_directive" 8046 8047 8048 public static class debug_directive_return extends ParserRuleReturnScope { 8049 CommonTree tree; 8050 @Override getTree()8051 public CommonTree getTree() { return tree; } 8052 }; 8053 8054 8055 // $ANTLR start "debug_directive" 8056 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:756:1: debug_directive : ( line_directive | local_directive | end_local_directive | restart_local_directive | prologue_directive | epilogue_directive | source_directive ); debug_directive()8057 public final smaliParser.debug_directive_return debug_directive() throws RecognitionException { 8058 smaliParser.debug_directive_return retval = new smaliParser.debug_directive_return(); 8059 retval.start = input.LT(1); 8060 8061 CommonTree root_0 = null; 8062 8063 ParserRuleReturnScope line_directive214 =null; 8064 ParserRuleReturnScope local_directive215 =null; 8065 ParserRuleReturnScope end_local_directive216 =null; 8066 ParserRuleReturnScope restart_local_directive217 =null; 8067 ParserRuleReturnScope prologue_directive218 =null; 8068 ParserRuleReturnScope epilogue_directive219 =null; 8069 ParserRuleReturnScope source_directive220 =null; 8070 8071 8072 try { 8073 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:757:3: ( line_directive | local_directive | end_local_directive | restart_local_directive | prologue_directive | epilogue_directive | source_directive ) 8074 int alt40=7; 8075 switch ( input.LA(1) ) { 8076 case LINE_DIRECTIVE: 8077 { 8078 alt40=1; 8079 } 8080 break; 8081 case LOCAL_DIRECTIVE: 8082 { 8083 alt40=2; 8084 } 8085 break; 8086 case END_LOCAL_DIRECTIVE: 8087 { 8088 alt40=3; 8089 } 8090 break; 8091 case RESTART_LOCAL_DIRECTIVE: 8092 { 8093 alt40=4; 8094 } 8095 break; 8096 case PROLOGUE_DIRECTIVE: 8097 { 8098 alt40=5; 8099 } 8100 break; 8101 case EPILOGUE_DIRECTIVE: 8102 { 8103 alt40=6; 8104 } 8105 break; 8106 case SOURCE_DIRECTIVE: 8107 { 8108 alt40=7; 8109 } 8110 break; 8111 default: 8112 NoViableAltException nvae = 8113 new NoViableAltException("", 40, 0, input); 8114 throw nvae; 8115 } 8116 switch (alt40) { 8117 case 1 : 8118 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:757:5: line_directive 8119 { 8120 root_0 = (CommonTree)adaptor.nil(); 8121 8122 8123 pushFollow(FOLLOW_line_directive_in_debug_directive3445); 8124 line_directive214=line_directive(); 8125 state._fsp--; 8126 8127 adaptor.addChild(root_0, line_directive214.getTree()); 8128 8129 } 8130 break; 8131 case 2 : 8132 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:758:5: local_directive 8133 { 8134 root_0 = (CommonTree)adaptor.nil(); 8135 8136 8137 pushFollow(FOLLOW_local_directive_in_debug_directive3451); 8138 local_directive215=local_directive(); 8139 state._fsp--; 8140 8141 adaptor.addChild(root_0, local_directive215.getTree()); 8142 8143 } 8144 break; 8145 case 3 : 8146 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:759:5: end_local_directive 8147 { 8148 root_0 = (CommonTree)adaptor.nil(); 8149 8150 8151 pushFollow(FOLLOW_end_local_directive_in_debug_directive3457); 8152 end_local_directive216=end_local_directive(); 8153 state._fsp--; 8154 8155 adaptor.addChild(root_0, end_local_directive216.getTree()); 8156 8157 } 8158 break; 8159 case 4 : 8160 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:760:5: restart_local_directive 8161 { 8162 root_0 = (CommonTree)adaptor.nil(); 8163 8164 8165 pushFollow(FOLLOW_restart_local_directive_in_debug_directive3463); 8166 restart_local_directive217=restart_local_directive(); 8167 state._fsp--; 8168 8169 adaptor.addChild(root_0, restart_local_directive217.getTree()); 8170 8171 } 8172 break; 8173 case 5 : 8174 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:761:5: prologue_directive 8175 { 8176 root_0 = (CommonTree)adaptor.nil(); 8177 8178 8179 pushFollow(FOLLOW_prologue_directive_in_debug_directive3469); 8180 prologue_directive218=prologue_directive(); 8181 state._fsp--; 8182 8183 adaptor.addChild(root_0, prologue_directive218.getTree()); 8184 8185 } 8186 break; 8187 case 6 : 8188 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:762:5: epilogue_directive 8189 { 8190 root_0 = (CommonTree)adaptor.nil(); 8191 8192 8193 pushFollow(FOLLOW_epilogue_directive_in_debug_directive3475); 8194 epilogue_directive219=epilogue_directive(); 8195 state._fsp--; 8196 8197 adaptor.addChild(root_0, epilogue_directive219.getTree()); 8198 8199 } 8200 break; 8201 case 7 : 8202 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:763:5: source_directive 8203 { 8204 root_0 = (CommonTree)adaptor.nil(); 8205 8206 8207 pushFollow(FOLLOW_source_directive_in_debug_directive3481); 8208 source_directive220=source_directive(); 8209 state._fsp--; 8210 8211 adaptor.addChild(root_0, source_directive220.getTree()); 8212 8213 } 8214 break; 8215 8216 } 8217 retval.stop = input.LT(-1); 8218 8219 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8220 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8221 8222 } 8223 catch (RecognitionException re) { 8224 reportError(re); 8225 recover(input,re); 8226 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8227 } 8228 finally { 8229 // do for sure before leaving 8230 } 8231 return retval; 8232 } 8233 // $ANTLR end "debug_directive" 8234 8235 8236 public static class line_directive_return extends ParserRuleReturnScope { 8237 CommonTree tree; 8238 @Override getTree()8239 public CommonTree getTree() { return tree; } 8240 }; 8241 8242 8243 // $ANTLR start "line_directive" 8244 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:765:1: line_directive : LINE_DIRECTIVE integral_literal -> ^( I_LINE[$start, \"I_LINE\"] integral_literal ) ; line_directive()8245 public final smaliParser.line_directive_return line_directive() throws RecognitionException { 8246 smaliParser.line_directive_return retval = new smaliParser.line_directive_return(); 8247 retval.start = input.LT(1); 8248 8249 CommonTree root_0 = null; 8250 8251 Token LINE_DIRECTIVE221=null; 8252 ParserRuleReturnScope integral_literal222 =null; 8253 8254 CommonTree LINE_DIRECTIVE221_tree=null; 8255 RewriteRuleTokenStream stream_LINE_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token LINE_DIRECTIVE"); 8256 RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal"); 8257 8258 try { 8259 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:766:3: ( LINE_DIRECTIVE integral_literal -> ^( I_LINE[$start, \"I_LINE\"] integral_literal ) ) 8260 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:766:5: LINE_DIRECTIVE integral_literal 8261 { 8262 LINE_DIRECTIVE221=(Token)match(input,LINE_DIRECTIVE,FOLLOW_LINE_DIRECTIVE_in_line_directive3491); 8263 stream_LINE_DIRECTIVE.add(LINE_DIRECTIVE221); 8264 8265 pushFollow(FOLLOW_integral_literal_in_line_directive3493); 8266 integral_literal222=integral_literal(); 8267 state._fsp--; 8268 8269 stream_integral_literal.add(integral_literal222.getTree()); 8270 // AST REWRITE 8271 // elements: integral_literal 8272 // token labels: 8273 // rule labels: retval 8274 // token list labels: 8275 // rule list labels: 8276 // wildcard labels: 8277 retval.tree = root_0; 8278 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 8279 8280 root_0 = (CommonTree)adaptor.nil(); 8281 // 767:5: -> ^( I_LINE[$start, \"I_LINE\"] integral_literal ) 8282 { 8283 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:767:8: ^( I_LINE[$start, \"I_LINE\"] integral_literal ) 8284 { 8285 CommonTree root_1 = (CommonTree)adaptor.nil(); 8286 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_LINE, (retval.start), "I_LINE"), root_1); 8287 adaptor.addChild(root_1, stream_integral_literal.nextTree()); 8288 adaptor.addChild(root_0, root_1); 8289 } 8290 8291 } 8292 8293 8294 retval.tree = root_0; 8295 8296 } 8297 8298 retval.stop = input.LT(-1); 8299 8300 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8301 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8302 8303 } 8304 catch (RecognitionException re) { 8305 reportError(re); 8306 recover(input,re); 8307 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8308 } 8309 finally { 8310 // do for sure before leaving 8311 } 8312 return retval; 8313 } 8314 // $ANTLR end "line_directive" 8315 8316 8317 public static class local_directive_return extends ParserRuleReturnScope { 8318 CommonTree tree; 8319 @Override getTree()8320 public CommonTree getTree() { return tree; } 8321 }; 8322 8323 8324 // $ANTLR start "local_directive" 8325 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:769: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)? ) ; local_directive()8326 public final smaliParser.local_directive_return local_directive() throws RecognitionException { 8327 smaliParser.local_directive_return retval = new smaliParser.local_directive_return(); 8328 retval.start = input.LT(1); 8329 8330 CommonTree root_0 = null; 8331 8332 Token name=null; 8333 Token signature=null; 8334 Token LOCAL_DIRECTIVE223=null; 8335 Token REGISTER224=null; 8336 Token COMMA225=null; 8337 Token NULL_LITERAL226=null; 8338 Token COLON227=null; 8339 Token VOID_TYPE228=null; 8340 Token COMMA230=null; 8341 ParserRuleReturnScope nonvoid_type_descriptor229 =null; 8342 8343 CommonTree name_tree=null; 8344 CommonTree signature_tree=null; 8345 CommonTree LOCAL_DIRECTIVE223_tree=null; 8346 CommonTree REGISTER224_tree=null; 8347 CommonTree COMMA225_tree=null; 8348 CommonTree NULL_LITERAL226_tree=null; 8349 CommonTree COLON227_tree=null; 8350 CommonTree VOID_TYPE228_tree=null; 8351 CommonTree COMMA230_tree=null; 8352 RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON"); 8353 RewriteRuleTokenStream stream_NULL_LITERAL=new RewriteRuleTokenStream(adaptor,"token NULL_LITERAL"); 8354 RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL"); 8355 RewriteRuleTokenStream stream_LOCAL_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token LOCAL_DIRECTIVE"); 8356 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 8357 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 8358 RewriteRuleTokenStream stream_VOID_TYPE=new RewriteRuleTokenStream(adaptor,"token VOID_TYPE"); 8359 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 8360 8361 try { 8362 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:770: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)? ) ) 8363 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:770:5: LOCAL_DIRECTIVE REGISTER ( COMMA ( NULL_LITERAL |name= STRING_LITERAL ) COLON ( VOID_TYPE | nonvoid_type_descriptor ) ( COMMA signature= STRING_LITERAL )? )? 8364 { 8365 LOCAL_DIRECTIVE223=(Token)match(input,LOCAL_DIRECTIVE,FOLLOW_LOCAL_DIRECTIVE_in_local_directive3516); 8366 stream_LOCAL_DIRECTIVE.add(LOCAL_DIRECTIVE223); 8367 8368 REGISTER224=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_local_directive3518); 8369 stream_REGISTER.add(REGISTER224); 8370 8371 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:770:30: ( COMMA ( NULL_LITERAL |name= STRING_LITERAL ) COLON ( VOID_TYPE | nonvoid_type_descriptor ) ( COMMA signature= STRING_LITERAL )? )? 8372 int alt44=2; 8373 int LA44_0 = input.LA(1); 8374 if ( (LA44_0==COMMA) ) { 8375 alt44=1; 8376 } 8377 switch (alt44) { 8378 case 1 : 8379 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:770:31: COMMA ( NULL_LITERAL |name= STRING_LITERAL ) COLON ( VOID_TYPE | nonvoid_type_descriptor ) ( COMMA signature= STRING_LITERAL )? 8380 { 8381 COMMA225=(Token)match(input,COMMA,FOLLOW_COMMA_in_local_directive3521); 8382 stream_COMMA.add(COMMA225); 8383 8384 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:770:37: ( NULL_LITERAL |name= STRING_LITERAL ) 8385 int alt41=2; 8386 int LA41_0 = input.LA(1); 8387 if ( (LA41_0==NULL_LITERAL) ) { 8388 alt41=1; 8389 } 8390 else if ( (LA41_0==STRING_LITERAL) ) { 8391 alt41=2; 8392 } 8393 8394 else { 8395 NoViableAltException nvae = 8396 new NoViableAltException("", 41, 0, input); 8397 throw nvae; 8398 } 8399 8400 switch (alt41) { 8401 case 1 : 8402 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:770:38: NULL_LITERAL 8403 { 8404 NULL_LITERAL226=(Token)match(input,NULL_LITERAL,FOLLOW_NULL_LITERAL_in_local_directive3524); 8405 stream_NULL_LITERAL.add(NULL_LITERAL226); 8406 8407 } 8408 break; 8409 case 2 : 8410 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:770:53: name= STRING_LITERAL 8411 { 8412 name=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_local_directive3530); 8413 stream_STRING_LITERAL.add(name); 8414 8415 } 8416 break; 8417 8418 } 8419 8420 COLON227=(Token)match(input,COLON,FOLLOW_COLON_in_local_directive3533); 8421 stream_COLON.add(COLON227); 8422 8423 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:770:80: ( VOID_TYPE | nonvoid_type_descriptor ) 8424 int alt42=2; 8425 int LA42_0 = input.LA(1); 8426 if ( (LA42_0==VOID_TYPE) ) { 8427 alt42=1; 8428 } 8429 else if ( (LA42_0==ARRAY_DESCRIPTOR||LA42_0==CLASS_DESCRIPTOR||LA42_0==PRIMITIVE_TYPE) ) { 8430 alt42=2; 8431 } 8432 8433 else { 8434 NoViableAltException nvae = 8435 new NoViableAltException("", 42, 0, input); 8436 throw nvae; 8437 } 8438 8439 switch (alt42) { 8440 case 1 : 8441 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:770:81: VOID_TYPE 8442 { 8443 VOID_TYPE228=(Token)match(input,VOID_TYPE,FOLLOW_VOID_TYPE_in_local_directive3536); 8444 stream_VOID_TYPE.add(VOID_TYPE228); 8445 8446 } 8447 break; 8448 case 2 : 8449 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:770:93: nonvoid_type_descriptor 8450 { 8451 pushFollow(FOLLOW_nonvoid_type_descriptor_in_local_directive3540); 8452 nonvoid_type_descriptor229=nonvoid_type_descriptor(); 8453 state._fsp--; 8454 8455 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor229.getTree()); 8456 } 8457 break; 8458 8459 } 8460 8461 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:771:31: ( COMMA signature= STRING_LITERAL )? 8462 int alt43=2; 8463 int LA43_0 = input.LA(1); 8464 if ( (LA43_0==COMMA) ) { 8465 alt43=1; 8466 } 8467 switch (alt43) { 8468 case 1 : 8469 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:771:32: COMMA signature= STRING_LITERAL 8470 { 8471 COMMA230=(Token)match(input,COMMA,FOLLOW_COMMA_in_local_directive3574); 8472 stream_COMMA.add(COMMA230); 8473 8474 signature=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_local_directive3578); 8475 stream_STRING_LITERAL.add(signature); 8476 8477 } 8478 break; 8479 8480 } 8481 8482 } 8483 break; 8484 8485 } 8486 8487 // AST REWRITE 8488 // elements: nonvoid_type_descriptor, name, signature, REGISTER, NULL_LITERAL 8489 // token labels: name, signature 8490 // rule labels: retval 8491 // token list labels: 8492 // rule list labels: 8493 // wildcard labels: 8494 retval.tree = root_0; 8495 RewriteRuleTokenStream stream_name=new RewriteRuleTokenStream(adaptor,"token name",name); 8496 RewriteRuleTokenStream stream_signature=new RewriteRuleTokenStream(adaptor,"token signature",signature); 8497 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 8498 8499 root_0 = (CommonTree)adaptor.nil(); 8500 // 772:5: -> ^( I_LOCAL[$start, \"I_LOCAL\"] REGISTER ( NULL_LITERAL )? ( $name)? ( nonvoid_type_descriptor )? ( $signature)? ) 8501 { 8502 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:772:8: ^( I_LOCAL[$start, \"I_LOCAL\"] REGISTER ( NULL_LITERAL )? ( $name)? ( nonvoid_type_descriptor )? ( $signature)? ) 8503 { 8504 CommonTree root_1 = (CommonTree)adaptor.nil(); 8505 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_LOCAL, (retval.start), "I_LOCAL"), root_1); 8506 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 8507 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:772:46: ( NULL_LITERAL )? 8508 if ( stream_NULL_LITERAL.hasNext() ) { 8509 adaptor.addChild(root_1, stream_NULL_LITERAL.nextNode()); 8510 } 8511 stream_NULL_LITERAL.reset(); 8512 8513 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:772:61: ( $name)? 8514 if ( stream_name.hasNext() ) { 8515 adaptor.addChild(root_1, stream_name.nextNode()); 8516 } 8517 stream_name.reset(); 8518 8519 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:772:67: ( nonvoid_type_descriptor )? 8520 if ( stream_nonvoid_type_descriptor.hasNext() ) { 8521 adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree()); 8522 } 8523 stream_nonvoid_type_descriptor.reset(); 8524 8525 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:772:93: ( $signature)? 8526 if ( stream_signature.hasNext() ) { 8527 adaptor.addChild(root_1, stream_signature.nextNode()); 8528 } 8529 stream_signature.reset(); 8530 8531 adaptor.addChild(root_0, root_1); 8532 } 8533 8534 } 8535 8536 8537 retval.tree = root_0; 8538 8539 } 8540 8541 retval.stop = input.LT(-1); 8542 8543 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8544 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8545 8546 } 8547 catch (RecognitionException re) { 8548 reportError(re); 8549 recover(input,re); 8550 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8551 } 8552 finally { 8553 // do for sure before leaving 8554 } 8555 return retval; 8556 } 8557 // $ANTLR end "local_directive" 8558 8559 8560 public static class end_local_directive_return extends ParserRuleReturnScope { 8561 CommonTree tree; 8562 @Override getTree()8563 public CommonTree getTree() { return tree; } 8564 }; 8565 8566 8567 // $ANTLR start "end_local_directive" 8568 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:774:1: end_local_directive : END_LOCAL_DIRECTIVE REGISTER -> ^( I_END_LOCAL[$start, \"I_END_LOCAL\"] REGISTER ) ; end_local_directive()8569 public final smaliParser.end_local_directive_return end_local_directive() throws RecognitionException { 8570 smaliParser.end_local_directive_return retval = new smaliParser.end_local_directive_return(); 8571 retval.start = input.LT(1); 8572 8573 CommonTree root_0 = null; 8574 8575 Token END_LOCAL_DIRECTIVE231=null; 8576 Token REGISTER232=null; 8577 8578 CommonTree END_LOCAL_DIRECTIVE231_tree=null; 8579 CommonTree REGISTER232_tree=null; 8580 RewriteRuleTokenStream stream_END_LOCAL_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_LOCAL_DIRECTIVE"); 8581 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 8582 8583 try { 8584 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:775:3: ( END_LOCAL_DIRECTIVE REGISTER -> ^( I_END_LOCAL[$start, \"I_END_LOCAL\"] REGISTER ) ) 8585 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:775:5: END_LOCAL_DIRECTIVE REGISTER 8586 { 8587 END_LOCAL_DIRECTIVE231=(Token)match(input,END_LOCAL_DIRECTIVE,FOLLOW_END_LOCAL_DIRECTIVE_in_end_local_directive3620); 8588 stream_END_LOCAL_DIRECTIVE.add(END_LOCAL_DIRECTIVE231); 8589 8590 REGISTER232=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_end_local_directive3622); 8591 stream_REGISTER.add(REGISTER232); 8592 8593 // AST REWRITE 8594 // elements: REGISTER 8595 // token labels: 8596 // rule labels: retval 8597 // token list labels: 8598 // rule list labels: 8599 // wildcard labels: 8600 retval.tree = root_0; 8601 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 8602 8603 root_0 = (CommonTree)adaptor.nil(); 8604 // 776:5: -> ^( I_END_LOCAL[$start, \"I_END_LOCAL\"] REGISTER ) 8605 { 8606 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:776:8: ^( I_END_LOCAL[$start, \"I_END_LOCAL\"] REGISTER ) 8607 { 8608 CommonTree root_1 = (CommonTree)adaptor.nil(); 8609 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_END_LOCAL, (retval.start), "I_END_LOCAL"), root_1); 8610 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 8611 adaptor.addChild(root_0, root_1); 8612 } 8613 8614 } 8615 8616 8617 retval.tree = root_0; 8618 8619 } 8620 8621 retval.stop = input.LT(-1); 8622 8623 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8624 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8625 8626 } 8627 catch (RecognitionException re) { 8628 reportError(re); 8629 recover(input,re); 8630 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8631 } 8632 finally { 8633 // do for sure before leaving 8634 } 8635 return retval; 8636 } 8637 // $ANTLR end "end_local_directive" 8638 8639 8640 public static class restart_local_directive_return extends ParserRuleReturnScope { 8641 CommonTree tree; 8642 @Override getTree()8643 public CommonTree getTree() { return tree; } 8644 }; 8645 8646 8647 // $ANTLR start "restart_local_directive" 8648 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:778:1: restart_local_directive : RESTART_LOCAL_DIRECTIVE REGISTER -> ^( I_RESTART_LOCAL[$start, \"I_RESTART_LOCAL\"] REGISTER ) ; restart_local_directive()8649 public final smaliParser.restart_local_directive_return restart_local_directive() throws RecognitionException { 8650 smaliParser.restart_local_directive_return retval = new smaliParser.restart_local_directive_return(); 8651 retval.start = input.LT(1); 8652 8653 CommonTree root_0 = null; 8654 8655 Token RESTART_LOCAL_DIRECTIVE233=null; 8656 Token REGISTER234=null; 8657 8658 CommonTree RESTART_LOCAL_DIRECTIVE233_tree=null; 8659 CommonTree REGISTER234_tree=null; 8660 RewriteRuleTokenStream stream_RESTART_LOCAL_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token RESTART_LOCAL_DIRECTIVE"); 8661 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 8662 8663 try { 8664 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:779:3: ( RESTART_LOCAL_DIRECTIVE REGISTER -> ^( I_RESTART_LOCAL[$start, \"I_RESTART_LOCAL\"] REGISTER ) ) 8665 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:779:5: RESTART_LOCAL_DIRECTIVE REGISTER 8666 { 8667 RESTART_LOCAL_DIRECTIVE233=(Token)match(input,RESTART_LOCAL_DIRECTIVE,FOLLOW_RESTART_LOCAL_DIRECTIVE_in_restart_local_directive3645); 8668 stream_RESTART_LOCAL_DIRECTIVE.add(RESTART_LOCAL_DIRECTIVE233); 8669 8670 REGISTER234=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_restart_local_directive3647); 8671 stream_REGISTER.add(REGISTER234); 8672 8673 // AST REWRITE 8674 // elements: REGISTER 8675 // token labels: 8676 // rule labels: retval 8677 // token list labels: 8678 // rule list labels: 8679 // wildcard labels: 8680 retval.tree = root_0; 8681 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 8682 8683 root_0 = (CommonTree)adaptor.nil(); 8684 // 780:5: -> ^( I_RESTART_LOCAL[$start, \"I_RESTART_LOCAL\"] REGISTER ) 8685 { 8686 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:780:8: ^( I_RESTART_LOCAL[$start, \"I_RESTART_LOCAL\"] REGISTER ) 8687 { 8688 CommonTree root_1 = (CommonTree)adaptor.nil(); 8689 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_RESTART_LOCAL, (retval.start), "I_RESTART_LOCAL"), root_1); 8690 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 8691 adaptor.addChild(root_0, root_1); 8692 } 8693 8694 } 8695 8696 8697 retval.tree = root_0; 8698 8699 } 8700 8701 retval.stop = input.LT(-1); 8702 8703 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8704 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8705 8706 } 8707 catch (RecognitionException re) { 8708 reportError(re); 8709 recover(input,re); 8710 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8711 } 8712 finally { 8713 // do for sure before leaving 8714 } 8715 return retval; 8716 } 8717 // $ANTLR end "restart_local_directive" 8718 8719 8720 public static class prologue_directive_return extends ParserRuleReturnScope { 8721 CommonTree tree; 8722 @Override getTree()8723 public CommonTree getTree() { return tree; } 8724 }; 8725 8726 8727 // $ANTLR start "prologue_directive" 8728 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:782:1: prologue_directive : PROLOGUE_DIRECTIVE -> ^( I_PROLOGUE[$start, \"I_PROLOGUE\"] ) ; prologue_directive()8729 public final smaliParser.prologue_directive_return prologue_directive() throws RecognitionException { 8730 smaliParser.prologue_directive_return retval = new smaliParser.prologue_directive_return(); 8731 retval.start = input.LT(1); 8732 8733 CommonTree root_0 = null; 8734 8735 Token PROLOGUE_DIRECTIVE235=null; 8736 8737 CommonTree PROLOGUE_DIRECTIVE235_tree=null; 8738 RewriteRuleTokenStream stream_PROLOGUE_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token PROLOGUE_DIRECTIVE"); 8739 8740 try { 8741 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:783:3: ( PROLOGUE_DIRECTIVE -> ^( I_PROLOGUE[$start, \"I_PROLOGUE\"] ) ) 8742 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:783:5: PROLOGUE_DIRECTIVE 8743 { 8744 PROLOGUE_DIRECTIVE235=(Token)match(input,PROLOGUE_DIRECTIVE,FOLLOW_PROLOGUE_DIRECTIVE_in_prologue_directive3670); 8745 stream_PROLOGUE_DIRECTIVE.add(PROLOGUE_DIRECTIVE235); 8746 8747 // AST REWRITE 8748 // elements: 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 // 784:5: -> ^( I_PROLOGUE[$start, \"I_PROLOGUE\"] ) 8759 { 8760 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:784:8: ^( I_PROLOGUE[$start, \"I_PROLOGUE\"] ) 8761 { 8762 CommonTree root_1 = (CommonTree)adaptor.nil(); 8763 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_PROLOGUE, (retval.start), "I_PROLOGUE"), root_1); 8764 adaptor.addChild(root_0, root_1); 8765 } 8766 8767 } 8768 8769 8770 retval.tree = root_0; 8771 8772 } 8773 8774 retval.stop = input.LT(-1); 8775 8776 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8777 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8778 8779 } 8780 catch (RecognitionException re) { 8781 reportError(re); 8782 recover(input,re); 8783 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8784 } 8785 finally { 8786 // do for sure before leaving 8787 } 8788 return retval; 8789 } 8790 // $ANTLR end "prologue_directive" 8791 8792 8793 public static class epilogue_directive_return extends ParserRuleReturnScope { 8794 CommonTree tree; 8795 @Override getTree()8796 public CommonTree getTree() { return tree; } 8797 }; 8798 8799 8800 // $ANTLR start "epilogue_directive" 8801 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:786:1: epilogue_directive : EPILOGUE_DIRECTIVE -> ^( I_EPILOGUE[$start, \"I_EPILOGUE\"] ) ; epilogue_directive()8802 public final smaliParser.epilogue_directive_return epilogue_directive() throws RecognitionException { 8803 smaliParser.epilogue_directive_return retval = new smaliParser.epilogue_directive_return(); 8804 retval.start = input.LT(1); 8805 8806 CommonTree root_0 = null; 8807 8808 Token EPILOGUE_DIRECTIVE236=null; 8809 8810 CommonTree EPILOGUE_DIRECTIVE236_tree=null; 8811 RewriteRuleTokenStream stream_EPILOGUE_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token EPILOGUE_DIRECTIVE"); 8812 8813 try { 8814 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:787:3: ( EPILOGUE_DIRECTIVE -> ^( I_EPILOGUE[$start, \"I_EPILOGUE\"] ) ) 8815 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:787:5: EPILOGUE_DIRECTIVE 8816 { 8817 EPILOGUE_DIRECTIVE236=(Token)match(input,EPILOGUE_DIRECTIVE,FOLLOW_EPILOGUE_DIRECTIVE_in_epilogue_directive3691); 8818 stream_EPILOGUE_DIRECTIVE.add(EPILOGUE_DIRECTIVE236); 8819 8820 // AST REWRITE 8821 // elements: 8822 // token labels: 8823 // rule labels: retval 8824 // token list labels: 8825 // rule list labels: 8826 // wildcard labels: 8827 retval.tree = root_0; 8828 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 8829 8830 root_0 = (CommonTree)adaptor.nil(); 8831 // 788:5: -> ^( I_EPILOGUE[$start, \"I_EPILOGUE\"] ) 8832 { 8833 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:788:8: ^( I_EPILOGUE[$start, \"I_EPILOGUE\"] ) 8834 { 8835 CommonTree root_1 = (CommonTree)adaptor.nil(); 8836 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_EPILOGUE, (retval.start), "I_EPILOGUE"), root_1); 8837 adaptor.addChild(root_0, root_1); 8838 } 8839 8840 } 8841 8842 8843 retval.tree = root_0; 8844 8845 } 8846 8847 retval.stop = input.LT(-1); 8848 8849 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8850 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8851 8852 } 8853 catch (RecognitionException re) { 8854 reportError(re); 8855 recover(input,re); 8856 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8857 } 8858 finally { 8859 // do for sure before leaving 8860 } 8861 return retval; 8862 } 8863 // $ANTLR end "epilogue_directive" 8864 8865 8866 public static class source_directive_return extends ParserRuleReturnScope { 8867 CommonTree tree; 8868 @Override getTree()8869 public CommonTree getTree() { return tree; } 8870 }; 8871 8872 8873 // $ANTLR start "source_directive" 8874 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:790:1: source_directive : SOURCE_DIRECTIVE ( STRING_LITERAL )? -> ^( I_SOURCE[$start, \"I_SOURCE\"] ( STRING_LITERAL )? ) ; source_directive()8875 public final smaliParser.source_directive_return source_directive() throws RecognitionException { 8876 smaliParser.source_directive_return retval = new smaliParser.source_directive_return(); 8877 retval.start = input.LT(1); 8878 8879 CommonTree root_0 = null; 8880 8881 Token SOURCE_DIRECTIVE237=null; 8882 Token STRING_LITERAL238=null; 8883 8884 CommonTree SOURCE_DIRECTIVE237_tree=null; 8885 CommonTree STRING_LITERAL238_tree=null; 8886 RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL"); 8887 RewriteRuleTokenStream stream_SOURCE_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token SOURCE_DIRECTIVE"); 8888 8889 try { 8890 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:791:3: ( SOURCE_DIRECTIVE ( STRING_LITERAL )? -> ^( I_SOURCE[$start, \"I_SOURCE\"] ( STRING_LITERAL )? ) ) 8891 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:791:5: SOURCE_DIRECTIVE ( STRING_LITERAL )? 8892 { 8893 SOURCE_DIRECTIVE237=(Token)match(input,SOURCE_DIRECTIVE,FOLLOW_SOURCE_DIRECTIVE_in_source_directive3712); 8894 stream_SOURCE_DIRECTIVE.add(SOURCE_DIRECTIVE237); 8895 8896 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:791:22: ( STRING_LITERAL )? 8897 int alt45=2; 8898 int LA45_0 = input.LA(1); 8899 if ( (LA45_0==STRING_LITERAL) ) { 8900 alt45=1; 8901 } 8902 switch (alt45) { 8903 case 1 : 8904 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:791:22: STRING_LITERAL 8905 { 8906 STRING_LITERAL238=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_source_directive3714); 8907 stream_STRING_LITERAL.add(STRING_LITERAL238); 8908 8909 } 8910 break; 8911 8912 } 8913 8914 // AST REWRITE 8915 // elements: STRING_LITERAL 8916 // token labels: 8917 // rule labels: retval 8918 // token list labels: 8919 // rule list labels: 8920 // wildcard labels: 8921 retval.tree = root_0; 8922 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 8923 8924 root_0 = (CommonTree)adaptor.nil(); 8925 // 792:5: -> ^( I_SOURCE[$start, \"I_SOURCE\"] ( STRING_LITERAL )? ) 8926 { 8927 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:792:8: ^( I_SOURCE[$start, \"I_SOURCE\"] ( STRING_LITERAL )? ) 8928 { 8929 CommonTree root_1 = (CommonTree)adaptor.nil(); 8930 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SOURCE, (retval.start), "I_SOURCE"), root_1); 8931 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:792:39: ( STRING_LITERAL )? 8932 if ( stream_STRING_LITERAL.hasNext() ) { 8933 adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode()); 8934 } 8935 stream_STRING_LITERAL.reset(); 8936 8937 adaptor.addChild(root_0, root_1); 8938 } 8939 8940 } 8941 8942 8943 retval.tree = root_0; 8944 8945 } 8946 8947 retval.stop = input.LT(-1); 8948 8949 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8950 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8951 8952 } 8953 catch (RecognitionException re) { 8954 reportError(re); 8955 recover(input,re); 8956 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8957 } 8958 finally { 8959 // do for sure before leaving 8960 } 8961 return retval; 8962 } 8963 // $ANTLR end "source_directive" 8964 8965 8966 public static class instruction_format12x_return extends ParserRuleReturnScope { 8967 CommonTree tree; 8968 @Override getTree()8969 public CommonTree getTree() { return tree; } 8970 }; 8971 8972 8973 // $ANTLR start "instruction_format12x" 8974 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:794:1: instruction_format12x : ( INSTRUCTION_FORMAT12x | INSTRUCTION_FORMAT12x_OR_ID -> INSTRUCTION_FORMAT12x[$INSTRUCTION_FORMAT12x_OR_ID] ); instruction_format12x()8975 public final smaliParser.instruction_format12x_return instruction_format12x() throws RecognitionException { 8976 smaliParser.instruction_format12x_return retval = new smaliParser.instruction_format12x_return(); 8977 retval.start = input.LT(1); 8978 8979 CommonTree root_0 = null; 8980 8981 Token INSTRUCTION_FORMAT12x239=null; 8982 Token INSTRUCTION_FORMAT12x_OR_ID240=null; 8983 8984 CommonTree INSTRUCTION_FORMAT12x239_tree=null; 8985 CommonTree INSTRUCTION_FORMAT12x_OR_ID240_tree=null; 8986 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT12x_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT12x_OR_ID"); 8987 8988 try { 8989 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:795:3: ( INSTRUCTION_FORMAT12x | INSTRUCTION_FORMAT12x_OR_ID -> INSTRUCTION_FORMAT12x[$INSTRUCTION_FORMAT12x_OR_ID] ) 8990 int alt46=2; 8991 int LA46_0 = input.LA(1); 8992 if ( (LA46_0==INSTRUCTION_FORMAT12x) ) { 8993 alt46=1; 8994 } 8995 else if ( (LA46_0==INSTRUCTION_FORMAT12x_OR_ID) ) { 8996 alt46=2; 8997 } 8998 8999 else { 9000 NoViableAltException nvae = 9001 new NoViableAltException("", 46, 0, input); 9002 throw nvae; 9003 } 9004 9005 switch (alt46) { 9006 case 1 : 9007 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:795:5: INSTRUCTION_FORMAT12x 9008 { 9009 root_0 = (CommonTree)adaptor.nil(); 9010 9011 9012 INSTRUCTION_FORMAT12x239=(Token)match(input,INSTRUCTION_FORMAT12x,FOLLOW_INSTRUCTION_FORMAT12x_in_instruction_format12x3739); 9013 INSTRUCTION_FORMAT12x239_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT12x239); 9014 adaptor.addChild(root_0, INSTRUCTION_FORMAT12x239_tree); 9015 9016 } 9017 break; 9018 case 2 : 9019 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:796:5: INSTRUCTION_FORMAT12x_OR_ID 9020 { 9021 INSTRUCTION_FORMAT12x_OR_ID240=(Token)match(input,INSTRUCTION_FORMAT12x_OR_ID,FOLLOW_INSTRUCTION_FORMAT12x_OR_ID_in_instruction_format12x3745); 9022 stream_INSTRUCTION_FORMAT12x_OR_ID.add(INSTRUCTION_FORMAT12x_OR_ID240); 9023 9024 // AST REWRITE 9025 // elements: 9026 // token labels: 9027 // rule labels: retval 9028 // token list labels: 9029 // rule list labels: 9030 // wildcard labels: 9031 retval.tree = root_0; 9032 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 9033 9034 root_0 = (CommonTree)adaptor.nil(); 9035 // 796:33: -> INSTRUCTION_FORMAT12x[$INSTRUCTION_FORMAT12x_OR_ID] 9036 { 9037 adaptor.addChild(root_0, (CommonTree)adaptor.create(INSTRUCTION_FORMAT12x, INSTRUCTION_FORMAT12x_OR_ID240)); 9038 } 9039 9040 9041 retval.tree = root_0; 9042 9043 } 9044 break; 9045 9046 } 9047 retval.stop = input.LT(-1); 9048 9049 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 9050 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 9051 9052 } 9053 catch (RecognitionException re) { 9054 reportError(re); 9055 recover(input,re); 9056 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 9057 } 9058 finally { 9059 // do for sure before leaving 9060 } 9061 return retval; 9062 } 9063 // $ANTLR end "instruction_format12x" 9064 9065 9066 public static class instruction_format22s_return extends ParserRuleReturnScope { 9067 CommonTree tree; 9068 @Override getTree()9069 public CommonTree getTree() { return tree; } 9070 }; 9071 9072 9073 // $ANTLR start "instruction_format22s" 9074 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:798:1: instruction_format22s : ( INSTRUCTION_FORMAT22s | INSTRUCTION_FORMAT22s_OR_ID -> INSTRUCTION_FORMAT22s[$INSTRUCTION_FORMAT22s_OR_ID] ); instruction_format22s()9075 public final smaliParser.instruction_format22s_return instruction_format22s() throws RecognitionException { 9076 smaliParser.instruction_format22s_return retval = new smaliParser.instruction_format22s_return(); 9077 retval.start = input.LT(1); 9078 9079 CommonTree root_0 = null; 9080 9081 Token INSTRUCTION_FORMAT22s241=null; 9082 Token INSTRUCTION_FORMAT22s_OR_ID242=null; 9083 9084 CommonTree INSTRUCTION_FORMAT22s241_tree=null; 9085 CommonTree INSTRUCTION_FORMAT22s_OR_ID242_tree=null; 9086 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22s_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22s_OR_ID"); 9087 9088 try { 9089 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:799:3: ( INSTRUCTION_FORMAT22s | INSTRUCTION_FORMAT22s_OR_ID -> INSTRUCTION_FORMAT22s[$INSTRUCTION_FORMAT22s_OR_ID] ) 9090 int alt47=2; 9091 int LA47_0 = input.LA(1); 9092 if ( (LA47_0==INSTRUCTION_FORMAT22s) ) { 9093 alt47=1; 9094 } 9095 else if ( (LA47_0==INSTRUCTION_FORMAT22s_OR_ID) ) { 9096 alt47=2; 9097 } 9098 9099 else { 9100 NoViableAltException nvae = 9101 new NoViableAltException("", 47, 0, input); 9102 throw nvae; 9103 } 9104 9105 switch (alt47) { 9106 case 1 : 9107 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:799:5: INSTRUCTION_FORMAT22s 9108 { 9109 root_0 = (CommonTree)adaptor.nil(); 9110 9111 9112 INSTRUCTION_FORMAT22s241=(Token)match(input,INSTRUCTION_FORMAT22s,FOLLOW_INSTRUCTION_FORMAT22s_in_instruction_format22s3760); 9113 INSTRUCTION_FORMAT22s241_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT22s241); 9114 adaptor.addChild(root_0, INSTRUCTION_FORMAT22s241_tree); 9115 9116 } 9117 break; 9118 case 2 : 9119 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:800:5: INSTRUCTION_FORMAT22s_OR_ID 9120 { 9121 INSTRUCTION_FORMAT22s_OR_ID242=(Token)match(input,INSTRUCTION_FORMAT22s_OR_ID,FOLLOW_INSTRUCTION_FORMAT22s_OR_ID_in_instruction_format22s3766); 9122 stream_INSTRUCTION_FORMAT22s_OR_ID.add(INSTRUCTION_FORMAT22s_OR_ID242); 9123 9124 // AST REWRITE 9125 // elements: 9126 // token labels: 9127 // rule labels: retval 9128 // token list labels: 9129 // rule list labels: 9130 // wildcard labels: 9131 retval.tree = root_0; 9132 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 9133 9134 root_0 = (CommonTree)adaptor.nil(); 9135 // 800:33: -> INSTRUCTION_FORMAT22s[$INSTRUCTION_FORMAT22s_OR_ID] 9136 { 9137 adaptor.addChild(root_0, (CommonTree)adaptor.create(INSTRUCTION_FORMAT22s, INSTRUCTION_FORMAT22s_OR_ID242)); 9138 } 9139 9140 9141 retval.tree = root_0; 9142 9143 } 9144 break; 9145 9146 } 9147 retval.stop = input.LT(-1); 9148 9149 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 9150 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 9151 9152 } 9153 catch (RecognitionException re) { 9154 reportError(re); 9155 recover(input,re); 9156 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 9157 } 9158 finally { 9159 // do for sure before leaving 9160 } 9161 return retval; 9162 } 9163 // $ANTLR end "instruction_format22s" 9164 9165 9166 public static class instruction_format31i_return extends ParserRuleReturnScope { 9167 CommonTree tree; 9168 @Override getTree()9169 public CommonTree getTree() { return tree; } 9170 }; 9171 9172 9173 // $ANTLR start "instruction_format31i" 9174 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:802:1: instruction_format31i : ( INSTRUCTION_FORMAT31i | INSTRUCTION_FORMAT31i_OR_ID -> INSTRUCTION_FORMAT31i[$INSTRUCTION_FORMAT31i_OR_ID] ); instruction_format31i()9175 public final smaliParser.instruction_format31i_return instruction_format31i() throws RecognitionException { 9176 smaliParser.instruction_format31i_return retval = new smaliParser.instruction_format31i_return(); 9177 retval.start = input.LT(1); 9178 9179 CommonTree root_0 = null; 9180 9181 Token INSTRUCTION_FORMAT31i243=null; 9182 Token INSTRUCTION_FORMAT31i_OR_ID244=null; 9183 9184 CommonTree INSTRUCTION_FORMAT31i243_tree=null; 9185 CommonTree INSTRUCTION_FORMAT31i_OR_ID244_tree=null; 9186 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT31i_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT31i_OR_ID"); 9187 9188 try { 9189 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:803:3: ( INSTRUCTION_FORMAT31i | INSTRUCTION_FORMAT31i_OR_ID -> INSTRUCTION_FORMAT31i[$INSTRUCTION_FORMAT31i_OR_ID] ) 9190 int alt48=2; 9191 int LA48_0 = input.LA(1); 9192 if ( (LA48_0==INSTRUCTION_FORMAT31i) ) { 9193 alt48=1; 9194 } 9195 else if ( (LA48_0==INSTRUCTION_FORMAT31i_OR_ID) ) { 9196 alt48=2; 9197 } 9198 9199 else { 9200 NoViableAltException nvae = 9201 new NoViableAltException("", 48, 0, input); 9202 throw nvae; 9203 } 9204 9205 switch (alt48) { 9206 case 1 : 9207 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:803:5: INSTRUCTION_FORMAT31i 9208 { 9209 root_0 = (CommonTree)adaptor.nil(); 9210 9211 9212 INSTRUCTION_FORMAT31i243=(Token)match(input,INSTRUCTION_FORMAT31i,FOLLOW_INSTRUCTION_FORMAT31i_in_instruction_format31i3781); 9213 INSTRUCTION_FORMAT31i243_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT31i243); 9214 adaptor.addChild(root_0, INSTRUCTION_FORMAT31i243_tree); 9215 9216 } 9217 break; 9218 case 2 : 9219 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:804:5: INSTRUCTION_FORMAT31i_OR_ID 9220 { 9221 INSTRUCTION_FORMAT31i_OR_ID244=(Token)match(input,INSTRUCTION_FORMAT31i_OR_ID,FOLLOW_INSTRUCTION_FORMAT31i_OR_ID_in_instruction_format31i3787); 9222 stream_INSTRUCTION_FORMAT31i_OR_ID.add(INSTRUCTION_FORMAT31i_OR_ID244); 9223 9224 // AST REWRITE 9225 // elements: 9226 // token labels: 9227 // rule labels: retval 9228 // token list labels: 9229 // rule list labels: 9230 // wildcard labels: 9231 retval.tree = root_0; 9232 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 9233 9234 root_0 = (CommonTree)adaptor.nil(); 9235 // 804:33: -> INSTRUCTION_FORMAT31i[$INSTRUCTION_FORMAT31i_OR_ID] 9236 { 9237 adaptor.addChild(root_0, (CommonTree)adaptor.create(INSTRUCTION_FORMAT31i, INSTRUCTION_FORMAT31i_OR_ID244)); 9238 } 9239 9240 9241 retval.tree = root_0; 9242 9243 } 9244 break; 9245 9246 } 9247 retval.stop = input.LT(-1); 9248 9249 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 9250 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 9251 9252 } 9253 catch (RecognitionException re) { 9254 reportError(re); 9255 recover(input,re); 9256 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 9257 } 9258 finally { 9259 // do for sure before leaving 9260 } 9261 return retval; 9262 } 9263 // $ANTLR end "instruction_format31i" 9264 9265 9266 public static class instruction_return extends ParserRuleReturnScope { 9267 CommonTree tree; 9268 @Override getTree()9269 public CommonTree getTree() { return tree; } 9270 }; 9271 9272 9273 // $ANTLR start "instruction" 9274 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:808: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_format21c_lambda | insn_format21c_method | insn_format21ih | insn_format21lh | insn_format21s | insn_format21t | insn_format22b | insn_format22c_field | insn_format22c_field_odex | insn_format22c_type | insn_format22c_string | insn_format22cs_field | insn_format22s | insn_format22t | insn_format22x | insn_format23x | insn_format25x | 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 ); instruction()9275 public final smaliParser.instruction_return instruction() throws RecognitionException { 9276 smaliParser.instruction_return retval = new smaliParser.instruction_return(); 9277 retval.start = input.LT(1); 9278 9279 CommonTree root_0 = null; 9280 9281 ParserRuleReturnScope insn_format10t245 =null; 9282 ParserRuleReturnScope insn_format10x246 =null; 9283 ParserRuleReturnScope insn_format10x_odex247 =null; 9284 ParserRuleReturnScope insn_format11n248 =null; 9285 ParserRuleReturnScope insn_format11x249 =null; 9286 ParserRuleReturnScope insn_format12x250 =null; 9287 ParserRuleReturnScope insn_format20bc251 =null; 9288 ParserRuleReturnScope insn_format20t252 =null; 9289 ParserRuleReturnScope insn_format21c_field253 =null; 9290 ParserRuleReturnScope insn_format21c_field_odex254 =null; 9291 ParserRuleReturnScope insn_format21c_string255 =null; 9292 ParserRuleReturnScope insn_format21c_type256 =null; 9293 ParserRuleReturnScope insn_format21c_lambda257 =null; 9294 ParserRuleReturnScope insn_format21c_method258 =null; 9295 ParserRuleReturnScope insn_format21ih259 =null; 9296 ParserRuleReturnScope insn_format21lh260 =null; 9297 ParserRuleReturnScope insn_format21s261 =null; 9298 ParserRuleReturnScope insn_format21t262 =null; 9299 ParserRuleReturnScope insn_format22b263 =null; 9300 ParserRuleReturnScope insn_format22c_field264 =null; 9301 ParserRuleReturnScope insn_format22c_field_odex265 =null; 9302 ParserRuleReturnScope insn_format22c_type266 =null; 9303 ParserRuleReturnScope insn_format22c_string267 =null; 9304 ParserRuleReturnScope insn_format22cs_field268 =null; 9305 ParserRuleReturnScope insn_format22s269 =null; 9306 ParserRuleReturnScope insn_format22t270 =null; 9307 ParserRuleReturnScope insn_format22x271 =null; 9308 ParserRuleReturnScope insn_format23x272 =null; 9309 ParserRuleReturnScope insn_format25x273 =null; 9310 ParserRuleReturnScope insn_format30t274 =null; 9311 ParserRuleReturnScope insn_format31c275 =null; 9312 ParserRuleReturnScope insn_format31i276 =null; 9313 ParserRuleReturnScope insn_format31t277 =null; 9314 ParserRuleReturnScope insn_format32x278 =null; 9315 ParserRuleReturnScope insn_format35c_method279 =null; 9316 ParserRuleReturnScope insn_format35c_type280 =null; 9317 ParserRuleReturnScope insn_format35c_method_odex281 =null; 9318 ParserRuleReturnScope insn_format35mi_method282 =null; 9319 ParserRuleReturnScope insn_format35ms_method283 =null; 9320 ParserRuleReturnScope insn_format3rc_method284 =null; 9321 ParserRuleReturnScope insn_format3rc_method_odex285 =null; 9322 ParserRuleReturnScope insn_format3rc_type286 =null; 9323 ParserRuleReturnScope insn_format3rmi_method287 =null; 9324 ParserRuleReturnScope insn_format3rms_method288 =null; 9325 ParserRuleReturnScope insn_format51l289 =null; 9326 ParserRuleReturnScope insn_array_data_directive290 =null; 9327 ParserRuleReturnScope insn_packed_switch_directive291 =null; 9328 ParserRuleReturnScope insn_sparse_switch_directive292 =null; 9329 9330 9331 try { 9332 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:809: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_format21c_lambda | insn_format21c_method | insn_format21ih | insn_format21lh | insn_format21s | insn_format21t | insn_format22b | insn_format22c_field | insn_format22c_field_odex | insn_format22c_type | insn_format22c_string | insn_format22cs_field | insn_format22s | insn_format22t | insn_format22x | insn_format23x | insn_format25x | 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 ) 9333 int alt49=48; 9334 switch ( input.LA(1) ) { 9335 case INSTRUCTION_FORMAT10t: 9336 { 9337 alt49=1; 9338 } 9339 break; 9340 case INSTRUCTION_FORMAT10x: 9341 { 9342 alt49=2; 9343 } 9344 break; 9345 case INSTRUCTION_FORMAT10x_ODEX: 9346 { 9347 alt49=3; 9348 } 9349 break; 9350 case INSTRUCTION_FORMAT11n: 9351 { 9352 alt49=4; 9353 } 9354 break; 9355 case INSTRUCTION_FORMAT11x: 9356 { 9357 alt49=5; 9358 } 9359 break; 9360 case INSTRUCTION_FORMAT12x: 9361 case INSTRUCTION_FORMAT12x_OR_ID: 9362 { 9363 alt49=6; 9364 } 9365 break; 9366 case INSTRUCTION_FORMAT20bc: 9367 { 9368 alt49=7; 9369 } 9370 break; 9371 case INSTRUCTION_FORMAT20t: 9372 { 9373 alt49=8; 9374 } 9375 break; 9376 case INSTRUCTION_FORMAT21c_FIELD: 9377 { 9378 alt49=9; 9379 } 9380 break; 9381 case INSTRUCTION_FORMAT21c_FIELD_ODEX: 9382 { 9383 alt49=10; 9384 } 9385 break; 9386 case INSTRUCTION_FORMAT21c_STRING: 9387 { 9388 alt49=11; 9389 } 9390 break; 9391 case INSTRUCTION_FORMAT21c_TYPE: 9392 { 9393 alt49=12; 9394 } 9395 break; 9396 case INSTRUCTION_FORMAT21c_LAMBDA: 9397 { 9398 alt49=13; 9399 } 9400 break; 9401 case INSTRUCTION_FORMAT21c_METHOD: 9402 { 9403 alt49=14; 9404 } 9405 break; 9406 case INSTRUCTION_FORMAT21ih: 9407 { 9408 alt49=15; 9409 } 9410 break; 9411 case INSTRUCTION_FORMAT21lh: 9412 { 9413 alt49=16; 9414 } 9415 break; 9416 case INSTRUCTION_FORMAT21s: 9417 { 9418 alt49=17; 9419 } 9420 break; 9421 case INSTRUCTION_FORMAT21t: 9422 { 9423 alt49=18; 9424 } 9425 break; 9426 case INSTRUCTION_FORMAT22b: 9427 { 9428 alt49=19; 9429 } 9430 break; 9431 case INSTRUCTION_FORMAT22c_FIELD: 9432 { 9433 alt49=20; 9434 } 9435 break; 9436 case INSTRUCTION_FORMAT22c_FIELD_ODEX: 9437 { 9438 alt49=21; 9439 } 9440 break; 9441 case INSTRUCTION_FORMAT22c_TYPE: 9442 { 9443 alt49=22; 9444 } 9445 break; 9446 case INSTRUCTION_FORMAT22c_STRING: 9447 { 9448 alt49=23; 9449 } 9450 break; 9451 case INSTRUCTION_FORMAT22cs_FIELD: 9452 { 9453 alt49=24; 9454 } 9455 break; 9456 case INSTRUCTION_FORMAT22s: 9457 case INSTRUCTION_FORMAT22s_OR_ID: 9458 { 9459 alt49=25; 9460 } 9461 break; 9462 case INSTRUCTION_FORMAT22t: 9463 { 9464 alt49=26; 9465 } 9466 break; 9467 case INSTRUCTION_FORMAT22x: 9468 { 9469 alt49=27; 9470 } 9471 break; 9472 case INSTRUCTION_FORMAT23x: 9473 { 9474 alt49=28; 9475 } 9476 break; 9477 case INSTRUCTION_FORMAT25x: 9478 { 9479 alt49=29; 9480 } 9481 break; 9482 case INSTRUCTION_FORMAT30t: 9483 { 9484 alt49=30; 9485 } 9486 break; 9487 case INSTRUCTION_FORMAT31c: 9488 { 9489 alt49=31; 9490 } 9491 break; 9492 case INSTRUCTION_FORMAT31i: 9493 case INSTRUCTION_FORMAT31i_OR_ID: 9494 { 9495 alt49=32; 9496 } 9497 break; 9498 case INSTRUCTION_FORMAT31t: 9499 { 9500 alt49=33; 9501 } 9502 break; 9503 case INSTRUCTION_FORMAT32x: 9504 { 9505 alt49=34; 9506 } 9507 break; 9508 case INSTRUCTION_FORMAT35c_METHOD: 9509 { 9510 alt49=35; 9511 } 9512 break; 9513 case INSTRUCTION_FORMAT35c_TYPE: 9514 { 9515 alt49=36; 9516 } 9517 break; 9518 case INSTRUCTION_FORMAT35c_METHOD_ODEX: 9519 { 9520 alt49=37; 9521 } 9522 break; 9523 case INSTRUCTION_FORMAT35mi_METHOD: 9524 { 9525 alt49=38; 9526 } 9527 break; 9528 case INSTRUCTION_FORMAT35ms_METHOD: 9529 { 9530 alt49=39; 9531 } 9532 break; 9533 case INSTRUCTION_FORMAT3rc_METHOD: 9534 { 9535 alt49=40; 9536 } 9537 break; 9538 case INSTRUCTION_FORMAT3rc_METHOD_ODEX: 9539 { 9540 alt49=41; 9541 } 9542 break; 9543 case INSTRUCTION_FORMAT3rc_TYPE: 9544 { 9545 alt49=42; 9546 } 9547 break; 9548 case INSTRUCTION_FORMAT3rmi_METHOD: 9549 { 9550 alt49=43; 9551 } 9552 break; 9553 case INSTRUCTION_FORMAT3rms_METHOD: 9554 { 9555 alt49=44; 9556 } 9557 break; 9558 case INSTRUCTION_FORMAT51l: 9559 { 9560 alt49=45; 9561 } 9562 break; 9563 case ARRAY_DATA_DIRECTIVE: 9564 { 9565 alt49=46; 9566 } 9567 break; 9568 case PACKED_SWITCH_DIRECTIVE: 9569 { 9570 alt49=47; 9571 } 9572 break; 9573 case SPARSE_SWITCH_DIRECTIVE: 9574 { 9575 alt49=48; 9576 } 9577 break; 9578 default: 9579 NoViableAltException nvae = 9580 new NoViableAltException("", 49, 0, input); 9581 throw nvae; 9582 } 9583 switch (alt49) { 9584 case 1 : 9585 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:809:5: insn_format10t 9586 { 9587 root_0 = (CommonTree)adaptor.nil(); 9588 9589 9590 pushFollow(FOLLOW_insn_format10t_in_instruction3804); 9591 insn_format10t245=insn_format10t(); 9592 state._fsp--; 9593 9594 adaptor.addChild(root_0, insn_format10t245.getTree()); 9595 9596 } 9597 break; 9598 case 2 : 9599 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:810:5: insn_format10x 9600 { 9601 root_0 = (CommonTree)adaptor.nil(); 9602 9603 9604 pushFollow(FOLLOW_insn_format10x_in_instruction3810); 9605 insn_format10x246=insn_format10x(); 9606 state._fsp--; 9607 9608 adaptor.addChild(root_0, insn_format10x246.getTree()); 9609 9610 } 9611 break; 9612 case 3 : 9613 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:811:5: insn_format10x_odex 9614 { 9615 root_0 = (CommonTree)adaptor.nil(); 9616 9617 9618 pushFollow(FOLLOW_insn_format10x_odex_in_instruction3816); 9619 insn_format10x_odex247=insn_format10x_odex(); 9620 state._fsp--; 9621 9622 adaptor.addChild(root_0, insn_format10x_odex247.getTree()); 9623 9624 } 9625 break; 9626 case 4 : 9627 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:812:5: insn_format11n 9628 { 9629 root_0 = (CommonTree)adaptor.nil(); 9630 9631 9632 pushFollow(FOLLOW_insn_format11n_in_instruction3822); 9633 insn_format11n248=insn_format11n(); 9634 state._fsp--; 9635 9636 adaptor.addChild(root_0, insn_format11n248.getTree()); 9637 9638 } 9639 break; 9640 case 5 : 9641 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:813:5: insn_format11x 9642 { 9643 root_0 = (CommonTree)adaptor.nil(); 9644 9645 9646 pushFollow(FOLLOW_insn_format11x_in_instruction3828); 9647 insn_format11x249=insn_format11x(); 9648 state._fsp--; 9649 9650 adaptor.addChild(root_0, insn_format11x249.getTree()); 9651 9652 } 9653 break; 9654 case 6 : 9655 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:814:5: insn_format12x 9656 { 9657 root_0 = (CommonTree)adaptor.nil(); 9658 9659 9660 pushFollow(FOLLOW_insn_format12x_in_instruction3834); 9661 insn_format12x250=insn_format12x(); 9662 state._fsp--; 9663 9664 adaptor.addChild(root_0, insn_format12x250.getTree()); 9665 9666 } 9667 break; 9668 case 7 : 9669 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:815:5: insn_format20bc 9670 { 9671 root_0 = (CommonTree)adaptor.nil(); 9672 9673 9674 pushFollow(FOLLOW_insn_format20bc_in_instruction3840); 9675 insn_format20bc251=insn_format20bc(); 9676 state._fsp--; 9677 9678 adaptor.addChild(root_0, insn_format20bc251.getTree()); 9679 9680 } 9681 break; 9682 case 8 : 9683 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:816:5: insn_format20t 9684 { 9685 root_0 = (CommonTree)adaptor.nil(); 9686 9687 9688 pushFollow(FOLLOW_insn_format20t_in_instruction3846); 9689 insn_format20t252=insn_format20t(); 9690 state._fsp--; 9691 9692 adaptor.addChild(root_0, insn_format20t252.getTree()); 9693 9694 } 9695 break; 9696 case 9 : 9697 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:817:5: insn_format21c_field 9698 { 9699 root_0 = (CommonTree)adaptor.nil(); 9700 9701 9702 pushFollow(FOLLOW_insn_format21c_field_in_instruction3852); 9703 insn_format21c_field253=insn_format21c_field(); 9704 state._fsp--; 9705 9706 adaptor.addChild(root_0, insn_format21c_field253.getTree()); 9707 9708 } 9709 break; 9710 case 10 : 9711 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:818:5: insn_format21c_field_odex 9712 { 9713 root_0 = (CommonTree)adaptor.nil(); 9714 9715 9716 pushFollow(FOLLOW_insn_format21c_field_odex_in_instruction3858); 9717 insn_format21c_field_odex254=insn_format21c_field_odex(); 9718 state._fsp--; 9719 9720 adaptor.addChild(root_0, insn_format21c_field_odex254.getTree()); 9721 9722 } 9723 break; 9724 case 11 : 9725 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:819:5: insn_format21c_string 9726 { 9727 root_0 = (CommonTree)adaptor.nil(); 9728 9729 9730 pushFollow(FOLLOW_insn_format21c_string_in_instruction3864); 9731 insn_format21c_string255=insn_format21c_string(); 9732 state._fsp--; 9733 9734 adaptor.addChild(root_0, insn_format21c_string255.getTree()); 9735 9736 } 9737 break; 9738 case 12 : 9739 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:820:5: insn_format21c_type 9740 { 9741 root_0 = (CommonTree)adaptor.nil(); 9742 9743 9744 pushFollow(FOLLOW_insn_format21c_type_in_instruction3870); 9745 insn_format21c_type256=insn_format21c_type(); 9746 state._fsp--; 9747 9748 adaptor.addChild(root_0, insn_format21c_type256.getTree()); 9749 9750 } 9751 break; 9752 case 13 : 9753 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:821:5: insn_format21c_lambda 9754 { 9755 root_0 = (CommonTree)adaptor.nil(); 9756 9757 9758 pushFollow(FOLLOW_insn_format21c_lambda_in_instruction3876); 9759 insn_format21c_lambda257=insn_format21c_lambda(); 9760 state._fsp--; 9761 9762 adaptor.addChild(root_0, insn_format21c_lambda257.getTree()); 9763 9764 } 9765 break; 9766 case 14 : 9767 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:822:5: insn_format21c_method 9768 { 9769 root_0 = (CommonTree)adaptor.nil(); 9770 9771 9772 pushFollow(FOLLOW_insn_format21c_method_in_instruction3882); 9773 insn_format21c_method258=insn_format21c_method(); 9774 state._fsp--; 9775 9776 adaptor.addChild(root_0, insn_format21c_method258.getTree()); 9777 9778 } 9779 break; 9780 case 15 : 9781 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:823:5: insn_format21ih 9782 { 9783 root_0 = (CommonTree)adaptor.nil(); 9784 9785 9786 pushFollow(FOLLOW_insn_format21ih_in_instruction3888); 9787 insn_format21ih259=insn_format21ih(); 9788 state._fsp--; 9789 9790 adaptor.addChild(root_0, insn_format21ih259.getTree()); 9791 9792 } 9793 break; 9794 case 16 : 9795 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:824:5: insn_format21lh 9796 { 9797 root_0 = (CommonTree)adaptor.nil(); 9798 9799 9800 pushFollow(FOLLOW_insn_format21lh_in_instruction3894); 9801 insn_format21lh260=insn_format21lh(); 9802 state._fsp--; 9803 9804 adaptor.addChild(root_0, insn_format21lh260.getTree()); 9805 9806 } 9807 break; 9808 case 17 : 9809 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:825:5: insn_format21s 9810 { 9811 root_0 = (CommonTree)adaptor.nil(); 9812 9813 9814 pushFollow(FOLLOW_insn_format21s_in_instruction3900); 9815 insn_format21s261=insn_format21s(); 9816 state._fsp--; 9817 9818 adaptor.addChild(root_0, insn_format21s261.getTree()); 9819 9820 } 9821 break; 9822 case 18 : 9823 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:826:5: insn_format21t 9824 { 9825 root_0 = (CommonTree)adaptor.nil(); 9826 9827 9828 pushFollow(FOLLOW_insn_format21t_in_instruction3906); 9829 insn_format21t262=insn_format21t(); 9830 state._fsp--; 9831 9832 adaptor.addChild(root_0, insn_format21t262.getTree()); 9833 9834 } 9835 break; 9836 case 19 : 9837 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:827:5: insn_format22b 9838 { 9839 root_0 = (CommonTree)adaptor.nil(); 9840 9841 9842 pushFollow(FOLLOW_insn_format22b_in_instruction3912); 9843 insn_format22b263=insn_format22b(); 9844 state._fsp--; 9845 9846 adaptor.addChild(root_0, insn_format22b263.getTree()); 9847 9848 } 9849 break; 9850 case 20 : 9851 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:828:5: insn_format22c_field 9852 { 9853 root_0 = (CommonTree)adaptor.nil(); 9854 9855 9856 pushFollow(FOLLOW_insn_format22c_field_in_instruction3918); 9857 insn_format22c_field264=insn_format22c_field(); 9858 state._fsp--; 9859 9860 adaptor.addChild(root_0, insn_format22c_field264.getTree()); 9861 9862 } 9863 break; 9864 case 21 : 9865 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:829:5: insn_format22c_field_odex 9866 { 9867 root_0 = (CommonTree)adaptor.nil(); 9868 9869 9870 pushFollow(FOLLOW_insn_format22c_field_odex_in_instruction3924); 9871 insn_format22c_field_odex265=insn_format22c_field_odex(); 9872 state._fsp--; 9873 9874 adaptor.addChild(root_0, insn_format22c_field_odex265.getTree()); 9875 9876 } 9877 break; 9878 case 22 : 9879 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:830:5: insn_format22c_type 9880 { 9881 root_0 = (CommonTree)adaptor.nil(); 9882 9883 9884 pushFollow(FOLLOW_insn_format22c_type_in_instruction3930); 9885 insn_format22c_type266=insn_format22c_type(); 9886 state._fsp--; 9887 9888 adaptor.addChild(root_0, insn_format22c_type266.getTree()); 9889 9890 } 9891 break; 9892 case 23 : 9893 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:831:5: insn_format22c_string 9894 { 9895 root_0 = (CommonTree)adaptor.nil(); 9896 9897 9898 pushFollow(FOLLOW_insn_format22c_string_in_instruction3936); 9899 insn_format22c_string267=insn_format22c_string(); 9900 state._fsp--; 9901 9902 adaptor.addChild(root_0, insn_format22c_string267.getTree()); 9903 9904 } 9905 break; 9906 case 24 : 9907 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:832:5: insn_format22cs_field 9908 { 9909 root_0 = (CommonTree)adaptor.nil(); 9910 9911 9912 pushFollow(FOLLOW_insn_format22cs_field_in_instruction3942); 9913 insn_format22cs_field268=insn_format22cs_field(); 9914 state._fsp--; 9915 9916 adaptor.addChild(root_0, insn_format22cs_field268.getTree()); 9917 9918 } 9919 break; 9920 case 25 : 9921 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:833:5: insn_format22s 9922 { 9923 root_0 = (CommonTree)adaptor.nil(); 9924 9925 9926 pushFollow(FOLLOW_insn_format22s_in_instruction3948); 9927 insn_format22s269=insn_format22s(); 9928 state._fsp--; 9929 9930 adaptor.addChild(root_0, insn_format22s269.getTree()); 9931 9932 } 9933 break; 9934 case 26 : 9935 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:834:5: insn_format22t 9936 { 9937 root_0 = (CommonTree)adaptor.nil(); 9938 9939 9940 pushFollow(FOLLOW_insn_format22t_in_instruction3954); 9941 insn_format22t270=insn_format22t(); 9942 state._fsp--; 9943 9944 adaptor.addChild(root_0, insn_format22t270.getTree()); 9945 9946 } 9947 break; 9948 case 27 : 9949 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:835:5: insn_format22x 9950 { 9951 root_0 = (CommonTree)adaptor.nil(); 9952 9953 9954 pushFollow(FOLLOW_insn_format22x_in_instruction3960); 9955 insn_format22x271=insn_format22x(); 9956 state._fsp--; 9957 9958 adaptor.addChild(root_0, insn_format22x271.getTree()); 9959 9960 } 9961 break; 9962 case 28 : 9963 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:836:5: insn_format23x 9964 { 9965 root_0 = (CommonTree)adaptor.nil(); 9966 9967 9968 pushFollow(FOLLOW_insn_format23x_in_instruction3966); 9969 insn_format23x272=insn_format23x(); 9970 state._fsp--; 9971 9972 adaptor.addChild(root_0, insn_format23x272.getTree()); 9973 9974 } 9975 break; 9976 case 29 : 9977 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:837:5: insn_format25x 9978 { 9979 root_0 = (CommonTree)adaptor.nil(); 9980 9981 9982 pushFollow(FOLLOW_insn_format25x_in_instruction3972); 9983 insn_format25x273=insn_format25x(); 9984 state._fsp--; 9985 9986 adaptor.addChild(root_0, insn_format25x273.getTree()); 9987 9988 } 9989 break; 9990 case 30 : 9991 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:838:5: insn_format30t 9992 { 9993 root_0 = (CommonTree)adaptor.nil(); 9994 9995 9996 pushFollow(FOLLOW_insn_format30t_in_instruction3978); 9997 insn_format30t274=insn_format30t(); 9998 state._fsp--; 9999 10000 adaptor.addChild(root_0, insn_format30t274.getTree()); 10001 10002 } 10003 break; 10004 case 31 : 10005 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:839:5: insn_format31c 10006 { 10007 root_0 = (CommonTree)adaptor.nil(); 10008 10009 10010 pushFollow(FOLLOW_insn_format31c_in_instruction3984); 10011 insn_format31c275=insn_format31c(); 10012 state._fsp--; 10013 10014 adaptor.addChild(root_0, insn_format31c275.getTree()); 10015 10016 } 10017 break; 10018 case 32 : 10019 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:840:5: insn_format31i 10020 { 10021 root_0 = (CommonTree)adaptor.nil(); 10022 10023 10024 pushFollow(FOLLOW_insn_format31i_in_instruction3990); 10025 insn_format31i276=insn_format31i(); 10026 state._fsp--; 10027 10028 adaptor.addChild(root_0, insn_format31i276.getTree()); 10029 10030 } 10031 break; 10032 case 33 : 10033 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:841:5: insn_format31t 10034 { 10035 root_0 = (CommonTree)adaptor.nil(); 10036 10037 10038 pushFollow(FOLLOW_insn_format31t_in_instruction3996); 10039 insn_format31t277=insn_format31t(); 10040 state._fsp--; 10041 10042 adaptor.addChild(root_0, insn_format31t277.getTree()); 10043 10044 } 10045 break; 10046 case 34 : 10047 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:842:5: insn_format32x 10048 { 10049 root_0 = (CommonTree)adaptor.nil(); 10050 10051 10052 pushFollow(FOLLOW_insn_format32x_in_instruction4002); 10053 insn_format32x278=insn_format32x(); 10054 state._fsp--; 10055 10056 adaptor.addChild(root_0, insn_format32x278.getTree()); 10057 10058 } 10059 break; 10060 case 35 : 10061 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:843:5: insn_format35c_method 10062 { 10063 root_0 = (CommonTree)adaptor.nil(); 10064 10065 10066 pushFollow(FOLLOW_insn_format35c_method_in_instruction4008); 10067 insn_format35c_method279=insn_format35c_method(); 10068 state._fsp--; 10069 10070 adaptor.addChild(root_0, insn_format35c_method279.getTree()); 10071 10072 } 10073 break; 10074 case 36 : 10075 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:844:5: insn_format35c_type 10076 { 10077 root_0 = (CommonTree)adaptor.nil(); 10078 10079 10080 pushFollow(FOLLOW_insn_format35c_type_in_instruction4014); 10081 insn_format35c_type280=insn_format35c_type(); 10082 state._fsp--; 10083 10084 adaptor.addChild(root_0, insn_format35c_type280.getTree()); 10085 10086 } 10087 break; 10088 case 37 : 10089 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:845:5: insn_format35c_method_odex 10090 { 10091 root_0 = (CommonTree)adaptor.nil(); 10092 10093 10094 pushFollow(FOLLOW_insn_format35c_method_odex_in_instruction4020); 10095 insn_format35c_method_odex281=insn_format35c_method_odex(); 10096 state._fsp--; 10097 10098 adaptor.addChild(root_0, insn_format35c_method_odex281.getTree()); 10099 10100 } 10101 break; 10102 case 38 : 10103 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:846:5: insn_format35mi_method 10104 { 10105 root_0 = (CommonTree)adaptor.nil(); 10106 10107 10108 pushFollow(FOLLOW_insn_format35mi_method_in_instruction4026); 10109 insn_format35mi_method282=insn_format35mi_method(); 10110 state._fsp--; 10111 10112 adaptor.addChild(root_0, insn_format35mi_method282.getTree()); 10113 10114 } 10115 break; 10116 case 39 : 10117 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:847:5: insn_format35ms_method 10118 { 10119 root_0 = (CommonTree)adaptor.nil(); 10120 10121 10122 pushFollow(FOLLOW_insn_format35ms_method_in_instruction4032); 10123 insn_format35ms_method283=insn_format35ms_method(); 10124 state._fsp--; 10125 10126 adaptor.addChild(root_0, insn_format35ms_method283.getTree()); 10127 10128 } 10129 break; 10130 case 40 : 10131 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:848:5: insn_format3rc_method 10132 { 10133 root_0 = (CommonTree)adaptor.nil(); 10134 10135 10136 pushFollow(FOLLOW_insn_format3rc_method_in_instruction4038); 10137 insn_format3rc_method284=insn_format3rc_method(); 10138 state._fsp--; 10139 10140 adaptor.addChild(root_0, insn_format3rc_method284.getTree()); 10141 10142 } 10143 break; 10144 case 41 : 10145 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:849:5: insn_format3rc_method_odex 10146 { 10147 root_0 = (CommonTree)adaptor.nil(); 10148 10149 10150 pushFollow(FOLLOW_insn_format3rc_method_odex_in_instruction4044); 10151 insn_format3rc_method_odex285=insn_format3rc_method_odex(); 10152 state._fsp--; 10153 10154 adaptor.addChild(root_0, insn_format3rc_method_odex285.getTree()); 10155 10156 } 10157 break; 10158 case 42 : 10159 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:850:5: insn_format3rc_type 10160 { 10161 root_0 = (CommonTree)adaptor.nil(); 10162 10163 10164 pushFollow(FOLLOW_insn_format3rc_type_in_instruction4050); 10165 insn_format3rc_type286=insn_format3rc_type(); 10166 state._fsp--; 10167 10168 adaptor.addChild(root_0, insn_format3rc_type286.getTree()); 10169 10170 } 10171 break; 10172 case 43 : 10173 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:851:5: insn_format3rmi_method 10174 { 10175 root_0 = (CommonTree)adaptor.nil(); 10176 10177 10178 pushFollow(FOLLOW_insn_format3rmi_method_in_instruction4056); 10179 insn_format3rmi_method287=insn_format3rmi_method(); 10180 state._fsp--; 10181 10182 adaptor.addChild(root_0, insn_format3rmi_method287.getTree()); 10183 10184 } 10185 break; 10186 case 44 : 10187 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:852:5: insn_format3rms_method 10188 { 10189 root_0 = (CommonTree)adaptor.nil(); 10190 10191 10192 pushFollow(FOLLOW_insn_format3rms_method_in_instruction4062); 10193 insn_format3rms_method288=insn_format3rms_method(); 10194 state._fsp--; 10195 10196 adaptor.addChild(root_0, insn_format3rms_method288.getTree()); 10197 10198 } 10199 break; 10200 case 45 : 10201 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:853:5: insn_format51l 10202 { 10203 root_0 = (CommonTree)adaptor.nil(); 10204 10205 10206 pushFollow(FOLLOW_insn_format51l_in_instruction4068); 10207 insn_format51l289=insn_format51l(); 10208 state._fsp--; 10209 10210 adaptor.addChild(root_0, insn_format51l289.getTree()); 10211 10212 } 10213 break; 10214 case 46 : 10215 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:854:5: insn_array_data_directive 10216 { 10217 root_0 = (CommonTree)adaptor.nil(); 10218 10219 10220 pushFollow(FOLLOW_insn_array_data_directive_in_instruction4074); 10221 insn_array_data_directive290=insn_array_data_directive(); 10222 state._fsp--; 10223 10224 adaptor.addChild(root_0, insn_array_data_directive290.getTree()); 10225 10226 } 10227 break; 10228 case 47 : 10229 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:855:5: insn_packed_switch_directive 10230 { 10231 root_0 = (CommonTree)adaptor.nil(); 10232 10233 10234 pushFollow(FOLLOW_insn_packed_switch_directive_in_instruction4080); 10235 insn_packed_switch_directive291=insn_packed_switch_directive(); 10236 state._fsp--; 10237 10238 adaptor.addChild(root_0, insn_packed_switch_directive291.getTree()); 10239 10240 } 10241 break; 10242 case 48 : 10243 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:856:5: insn_sparse_switch_directive 10244 { 10245 root_0 = (CommonTree)adaptor.nil(); 10246 10247 10248 pushFollow(FOLLOW_insn_sparse_switch_directive_in_instruction4086); 10249 insn_sparse_switch_directive292=insn_sparse_switch_directive(); 10250 state._fsp--; 10251 10252 adaptor.addChild(root_0, insn_sparse_switch_directive292.getTree()); 10253 10254 } 10255 break; 10256 10257 } 10258 retval.stop = input.LT(-1); 10259 10260 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10261 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10262 10263 } 10264 catch (RecognitionException re) { 10265 reportError(re); 10266 recover(input,re); 10267 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10268 } 10269 finally { 10270 // do for sure before leaving 10271 } 10272 return retval; 10273 } 10274 // $ANTLR end "instruction" 10275 10276 10277 public static class insn_format10t_return extends ParserRuleReturnScope { 10278 CommonTree tree; 10279 @Override getTree()10280 public CommonTree getTree() { return tree; } 10281 }; 10282 10283 10284 // $ANTLR start "insn_format10t" 10285 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:858:1: insn_format10t : INSTRUCTION_FORMAT10t label_ref -> ^( I_STATEMENT_FORMAT10t[$start, \"I_STATEMENT_FORMAT10t\"] INSTRUCTION_FORMAT10t label_ref ) ; insn_format10t()10286 public final smaliParser.insn_format10t_return insn_format10t() throws RecognitionException { 10287 smaliParser.insn_format10t_return retval = new smaliParser.insn_format10t_return(); 10288 retval.start = input.LT(1); 10289 10290 CommonTree root_0 = null; 10291 10292 Token INSTRUCTION_FORMAT10t293=null; 10293 ParserRuleReturnScope label_ref294 =null; 10294 10295 CommonTree INSTRUCTION_FORMAT10t293_tree=null; 10296 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT10t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT10t"); 10297 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 10298 10299 try { 10300 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:859:3: ( INSTRUCTION_FORMAT10t label_ref -> ^( I_STATEMENT_FORMAT10t[$start, \"I_STATEMENT_FORMAT10t\"] INSTRUCTION_FORMAT10t label_ref ) ) 10301 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:861:5: INSTRUCTION_FORMAT10t label_ref 10302 { 10303 INSTRUCTION_FORMAT10t293=(Token)match(input,INSTRUCTION_FORMAT10t,FOLLOW_INSTRUCTION_FORMAT10t_in_insn_format10t4106); 10304 stream_INSTRUCTION_FORMAT10t.add(INSTRUCTION_FORMAT10t293); 10305 10306 pushFollow(FOLLOW_label_ref_in_insn_format10t4108); 10307 label_ref294=label_ref(); 10308 state._fsp--; 10309 10310 stream_label_ref.add(label_ref294.getTree()); 10311 // AST REWRITE 10312 // elements: label_ref, INSTRUCTION_FORMAT10t 10313 // token labels: 10314 // rule labels: retval 10315 // token list labels: 10316 // rule list labels: 10317 // wildcard labels: 10318 retval.tree = root_0; 10319 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10320 10321 root_0 = (CommonTree)adaptor.nil(); 10322 // 862:5: -> ^( I_STATEMENT_FORMAT10t[$start, \"I_STATEMENT_FORMAT10t\"] INSTRUCTION_FORMAT10t label_ref ) 10323 { 10324 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:862:8: ^( I_STATEMENT_FORMAT10t[$start, \"I_STATEMENT_FORMAT10t\"] INSTRUCTION_FORMAT10t label_ref ) 10325 { 10326 CommonTree root_1 = (CommonTree)adaptor.nil(); 10327 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT10t, (retval.start), "I_STATEMENT_FORMAT10t"), root_1); 10328 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT10t.nextNode()); 10329 adaptor.addChild(root_1, stream_label_ref.nextTree()); 10330 adaptor.addChild(root_0, root_1); 10331 } 10332 10333 } 10334 10335 10336 retval.tree = root_0; 10337 10338 } 10339 10340 retval.stop = input.LT(-1); 10341 10342 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10343 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10344 10345 } 10346 catch (RecognitionException re) { 10347 reportError(re); 10348 recover(input,re); 10349 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10350 } 10351 finally { 10352 // do for sure before leaving 10353 } 10354 return retval; 10355 } 10356 // $ANTLR end "insn_format10t" 10357 10358 10359 public static class insn_format10x_return extends ParserRuleReturnScope { 10360 CommonTree tree; 10361 @Override getTree()10362 public CommonTree getTree() { return tree; } 10363 }; 10364 10365 10366 // $ANTLR start "insn_format10x" 10367 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:864:1: insn_format10x : INSTRUCTION_FORMAT10x -> ^( I_STATEMENT_FORMAT10x[$start, \"I_STATEMENT_FORMAT10x\"] INSTRUCTION_FORMAT10x ) ; insn_format10x()10368 public final smaliParser.insn_format10x_return insn_format10x() throws RecognitionException { 10369 smaliParser.insn_format10x_return retval = new smaliParser.insn_format10x_return(); 10370 retval.start = input.LT(1); 10371 10372 CommonTree root_0 = null; 10373 10374 Token INSTRUCTION_FORMAT10x295=null; 10375 10376 CommonTree INSTRUCTION_FORMAT10x295_tree=null; 10377 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT10x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT10x"); 10378 10379 try { 10380 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:865:3: ( INSTRUCTION_FORMAT10x -> ^( I_STATEMENT_FORMAT10x[$start, \"I_STATEMENT_FORMAT10x\"] INSTRUCTION_FORMAT10x ) ) 10381 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:866:5: INSTRUCTION_FORMAT10x 10382 { 10383 INSTRUCTION_FORMAT10x295=(Token)match(input,INSTRUCTION_FORMAT10x,FOLLOW_INSTRUCTION_FORMAT10x_in_insn_format10x4138); 10384 stream_INSTRUCTION_FORMAT10x.add(INSTRUCTION_FORMAT10x295); 10385 10386 // AST REWRITE 10387 // elements: INSTRUCTION_FORMAT10x 10388 // token labels: 10389 // rule labels: retval 10390 // token list labels: 10391 // rule list labels: 10392 // wildcard labels: 10393 retval.tree = root_0; 10394 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10395 10396 root_0 = (CommonTree)adaptor.nil(); 10397 // 867:5: -> ^( I_STATEMENT_FORMAT10x[$start, \"I_STATEMENT_FORMAT10x\"] INSTRUCTION_FORMAT10x ) 10398 { 10399 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:867:8: ^( I_STATEMENT_FORMAT10x[$start, \"I_STATEMENT_FORMAT10x\"] INSTRUCTION_FORMAT10x ) 10400 { 10401 CommonTree root_1 = (CommonTree)adaptor.nil(); 10402 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT10x, (retval.start), "I_STATEMENT_FORMAT10x"), root_1); 10403 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT10x.nextNode()); 10404 adaptor.addChild(root_0, root_1); 10405 } 10406 10407 } 10408 10409 10410 retval.tree = root_0; 10411 10412 } 10413 10414 retval.stop = input.LT(-1); 10415 10416 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10417 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10418 10419 } 10420 catch (RecognitionException re) { 10421 reportError(re); 10422 recover(input,re); 10423 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10424 } 10425 finally { 10426 // do for sure before leaving 10427 } 10428 return retval; 10429 } 10430 // $ANTLR end "insn_format10x" 10431 10432 10433 public static class insn_format10x_odex_return extends ParserRuleReturnScope { 10434 CommonTree tree; 10435 @Override getTree()10436 public CommonTree getTree() { return tree; } 10437 }; 10438 10439 10440 // $ANTLR start "insn_format10x_odex" 10441 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:869:1: insn_format10x_odex : INSTRUCTION_FORMAT10x_ODEX ; insn_format10x_odex()10442 public final smaliParser.insn_format10x_odex_return insn_format10x_odex() throws RecognitionException { 10443 smaliParser.insn_format10x_odex_return retval = new smaliParser.insn_format10x_odex_return(); 10444 retval.start = input.LT(1); 10445 10446 CommonTree root_0 = null; 10447 10448 Token INSTRUCTION_FORMAT10x_ODEX296=null; 10449 10450 CommonTree INSTRUCTION_FORMAT10x_ODEX296_tree=null; 10451 10452 try { 10453 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:870:3: ( INSTRUCTION_FORMAT10x_ODEX ) 10454 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:871:5: INSTRUCTION_FORMAT10x_ODEX 10455 { 10456 root_0 = (CommonTree)adaptor.nil(); 10457 10458 10459 INSTRUCTION_FORMAT10x_ODEX296=(Token)match(input,INSTRUCTION_FORMAT10x_ODEX,FOLLOW_INSTRUCTION_FORMAT10x_ODEX_in_insn_format10x_odex4166); 10460 INSTRUCTION_FORMAT10x_ODEX296_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT10x_ODEX296); 10461 adaptor.addChild(root_0, INSTRUCTION_FORMAT10x_ODEX296_tree); 10462 10463 10464 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT10x_ODEX296!=null?INSTRUCTION_FORMAT10x_ODEX296.getText():null)); 10465 10466 } 10467 10468 retval.stop = input.LT(-1); 10469 10470 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10471 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10472 10473 } 10474 catch (RecognitionException re) { 10475 reportError(re); 10476 recover(input,re); 10477 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10478 } 10479 finally { 10480 // do for sure before leaving 10481 } 10482 return retval; 10483 } 10484 // $ANTLR end "insn_format10x_odex" 10485 10486 10487 public static class insn_format11n_return extends ParserRuleReturnScope { 10488 CommonTree tree; 10489 @Override getTree()10490 public CommonTree getTree() { return tree; } 10491 }; 10492 10493 10494 // $ANTLR start "insn_format11n" 10495 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:876:1: insn_format11n : INSTRUCTION_FORMAT11n REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT11n[$start, \"I_STATEMENT_FORMAT11n\"] INSTRUCTION_FORMAT11n REGISTER integral_literal ) ; insn_format11n()10496 public final smaliParser.insn_format11n_return insn_format11n() throws RecognitionException { 10497 smaliParser.insn_format11n_return retval = new smaliParser.insn_format11n_return(); 10498 retval.start = input.LT(1); 10499 10500 CommonTree root_0 = null; 10501 10502 Token INSTRUCTION_FORMAT11n297=null; 10503 Token REGISTER298=null; 10504 Token COMMA299=null; 10505 ParserRuleReturnScope integral_literal300 =null; 10506 10507 CommonTree INSTRUCTION_FORMAT11n297_tree=null; 10508 CommonTree REGISTER298_tree=null; 10509 CommonTree COMMA299_tree=null; 10510 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 10511 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 10512 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT11n=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT11n"); 10513 RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal"); 10514 10515 try { 10516 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:877:3: ( INSTRUCTION_FORMAT11n REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT11n[$start, \"I_STATEMENT_FORMAT11n\"] INSTRUCTION_FORMAT11n REGISTER integral_literal ) ) 10517 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:878:5: INSTRUCTION_FORMAT11n REGISTER COMMA integral_literal 10518 { 10519 INSTRUCTION_FORMAT11n297=(Token)match(input,INSTRUCTION_FORMAT11n,FOLLOW_INSTRUCTION_FORMAT11n_in_insn_format11n4187); 10520 stream_INSTRUCTION_FORMAT11n.add(INSTRUCTION_FORMAT11n297); 10521 10522 REGISTER298=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format11n4189); 10523 stream_REGISTER.add(REGISTER298); 10524 10525 COMMA299=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format11n4191); 10526 stream_COMMA.add(COMMA299); 10527 10528 pushFollow(FOLLOW_integral_literal_in_insn_format11n4193); 10529 integral_literal300=integral_literal(); 10530 state._fsp--; 10531 10532 stream_integral_literal.add(integral_literal300.getTree()); 10533 // AST REWRITE 10534 // elements: integral_literal, REGISTER, INSTRUCTION_FORMAT11n 10535 // token labels: 10536 // rule labels: retval 10537 // token list labels: 10538 // rule list labels: 10539 // wildcard labels: 10540 retval.tree = root_0; 10541 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10542 10543 root_0 = (CommonTree)adaptor.nil(); 10544 // 879:5: -> ^( I_STATEMENT_FORMAT11n[$start, \"I_STATEMENT_FORMAT11n\"] INSTRUCTION_FORMAT11n REGISTER integral_literal ) 10545 { 10546 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:879:8: ^( I_STATEMENT_FORMAT11n[$start, \"I_STATEMENT_FORMAT11n\"] INSTRUCTION_FORMAT11n REGISTER integral_literal ) 10547 { 10548 CommonTree root_1 = (CommonTree)adaptor.nil(); 10549 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT11n, (retval.start), "I_STATEMENT_FORMAT11n"), root_1); 10550 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT11n.nextNode()); 10551 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 10552 adaptor.addChild(root_1, stream_integral_literal.nextTree()); 10553 adaptor.addChild(root_0, root_1); 10554 } 10555 10556 } 10557 10558 10559 retval.tree = root_0; 10560 10561 } 10562 10563 retval.stop = input.LT(-1); 10564 10565 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10566 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10567 10568 } 10569 catch (RecognitionException re) { 10570 reportError(re); 10571 recover(input,re); 10572 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10573 } 10574 finally { 10575 // do for sure before leaving 10576 } 10577 return retval; 10578 } 10579 // $ANTLR end "insn_format11n" 10580 10581 10582 public static class insn_format11x_return extends ParserRuleReturnScope { 10583 CommonTree tree; 10584 @Override getTree()10585 public CommonTree getTree() { return tree; } 10586 }; 10587 10588 10589 // $ANTLR start "insn_format11x" 10590 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:881:1: insn_format11x : INSTRUCTION_FORMAT11x REGISTER -> ^( I_STATEMENT_FORMAT11x[$start, \"I_STATEMENT_FORMAT11x\"] INSTRUCTION_FORMAT11x REGISTER ) ; insn_format11x()10591 public final smaliParser.insn_format11x_return insn_format11x() throws RecognitionException { 10592 smaliParser.insn_format11x_return retval = new smaliParser.insn_format11x_return(); 10593 retval.start = input.LT(1); 10594 10595 CommonTree root_0 = null; 10596 10597 Token INSTRUCTION_FORMAT11x301=null; 10598 Token REGISTER302=null; 10599 10600 CommonTree INSTRUCTION_FORMAT11x301_tree=null; 10601 CommonTree REGISTER302_tree=null; 10602 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT11x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT11x"); 10603 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 10604 10605 try { 10606 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:882:3: ( INSTRUCTION_FORMAT11x REGISTER -> ^( I_STATEMENT_FORMAT11x[$start, \"I_STATEMENT_FORMAT11x\"] INSTRUCTION_FORMAT11x REGISTER ) ) 10607 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:883:5: INSTRUCTION_FORMAT11x REGISTER 10608 { 10609 INSTRUCTION_FORMAT11x301=(Token)match(input,INSTRUCTION_FORMAT11x,FOLLOW_INSTRUCTION_FORMAT11x_in_insn_format11x4225); 10610 stream_INSTRUCTION_FORMAT11x.add(INSTRUCTION_FORMAT11x301); 10611 10612 REGISTER302=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format11x4227); 10613 stream_REGISTER.add(REGISTER302); 10614 10615 // AST REWRITE 10616 // elements: INSTRUCTION_FORMAT11x, REGISTER 10617 // token labels: 10618 // rule labels: retval 10619 // token list labels: 10620 // rule list labels: 10621 // wildcard labels: 10622 retval.tree = root_0; 10623 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10624 10625 root_0 = (CommonTree)adaptor.nil(); 10626 // 884:5: -> ^( I_STATEMENT_FORMAT11x[$start, \"I_STATEMENT_FORMAT11x\"] INSTRUCTION_FORMAT11x REGISTER ) 10627 { 10628 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:884:8: ^( I_STATEMENT_FORMAT11x[$start, \"I_STATEMENT_FORMAT11x\"] INSTRUCTION_FORMAT11x REGISTER ) 10629 { 10630 CommonTree root_1 = (CommonTree)adaptor.nil(); 10631 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT11x, (retval.start), "I_STATEMENT_FORMAT11x"), root_1); 10632 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT11x.nextNode()); 10633 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 10634 adaptor.addChild(root_0, root_1); 10635 } 10636 10637 } 10638 10639 10640 retval.tree = root_0; 10641 10642 } 10643 10644 retval.stop = input.LT(-1); 10645 10646 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10647 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10648 10649 } 10650 catch (RecognitionException re) { 10651 reportError(re); 10652 recover(input,re); 10653 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10654 } 10655 finally { 10656 // do for sure before leaving 10657 } 10658 return retval; 10659 } 10660 // $ANTLR end "insn_format11x" 10661 10662 10663 public static class insn_format12x_return extends ParserRuleReturnScope { 10664 CommonTree tree; 10665 @Override getTree()10666 public CommonTree getTree() { return tree; } 10667 }; 10668 10669 10670 // $ANTLR start "insn_format12x" 10671 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:886:1: insn_format12x : instruction_format12x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT12x[$start, \"I_STATEMENT_FORMAT12x\"] instruction_format12x REGISTER REGISTER ) ; insn_format12x()10672 public final smaliParser.insn_format12x_return insn_format12x() throws RecognitionException { 10673 smaliParser.insn_format12x_return retval = new smaliParser.insn_format12x_return(); 10674 retval.start = input.LT(1); 10675 10676 CommonTree root_0 = null; 10677 10678 Token REGISTER304=null; 10679 Token COMMA305=null; 10680 Token REGISTER306=null; 10681 ParserRuleReturnScope instruction_format12x303 =null; 10682 10683 CommonTree REGISTER304_tree=null; 10684 CommonTree COMMA305_tree=null; 10685 CommonTree REGISTER306_tree=null; 10686 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 10687 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 10688 RewriteRuleSubtreeStream stream_instruction_format12x=new RewriteRuleSubtreeStream(adaptor,"rule instruction_format12x"); 10689 10690 try { 10691 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:887:3: ( instruction_format12x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT12x[$start, \"I_STATEMENT_FORMAT12x\"] instruction_format12x REGISTER REGISTER ) ) 10692 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:888:5: instruction_format12x REGISTER COMMA REGISTER 10693 { 10694 pushFollow(FOLLOW_instruction_format12x_in_insn_format12x4257); 10695 instruction_format12x303=instruction_format12x(); 10696 state._fsp--; 10697 10698 stream_instruction_format12x.add(instruction_format12x303.getTree()); 10699 REGISTER304=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format12x4259); 10700 stream_REGISTER.add(REGISTER304); 10701 10702 COMMA305=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format12x4261); 10703 stream_COMMA.add(COMMA305); 10704 10705 REGISTER306=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format12x4263); 10706 stream_REGISTER.add(REGISTER306); 10707 10708 // AST REWRITE 10709 // elements: REGISTER, instruction_format12x, REGISTER 10710 // token labels: 10711 // rule labels: retval 10712 // token list labels: 10713 // rule list labels: 10714 // wildcard labels: 10715 retval.tree = root_0; 10716 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10717 10718 root_0 = (CommonTree)adaptor.nil(); 10719 // 889:5: -> ^( I_STATEMENT_FORMAT12x[$start, \"I_STATEMENT_FORMAT12x\"] instruction_format12x REGISTER REGISTER ) 10720 { 10721 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:889:8: ^( I_STATEMENT_FORMAT12x[$start, \"I_STATEMENT_FORMAT12x\"] instruction_format12x REGISTER REGISTER ) 10722 { 10723 CommonTree root_1 = (CommonTree)adaptor.nil(); 10724 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT12x, (retval.start), "I_STATEMENT_FORMAT12x"), root_1); 10725 adaptor.addChild(root_1, stream_instruction_format12x.nextTree()); 10726 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 10727 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 10728 adaptor.addChild(root_0, root_1); 10729 } 10730 10731 } 10732 10733 10734 retval.tree = root_0; 10735 10736 } 10737 10738 retval.stop = input.LT(-1); 10739 10740 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10741 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10742 10743 } 10744 catch (RecognitionException re) { 10745 reportError(re); 10746 recover(input,re); 10747 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10748 } 10749 finally { 10750 // do for sure before leaving 10751 } 10752 return retval; 10753 } 10754 // $ANTLR end "insn_format12x" 10755 10756 10757 public static class insn_format20bc_return extends ParserRuleReturnScope { 10758 CommonTree tree; 10759 @Override getTree()10760 public CommonTree getTree() { return tree; } 10761 }; 10762 10763 10764 // $ANTLR start "insn_format20bc" 10765 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:891:1: insn_format20bc : INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE COMMA verification_error_reference -> ^( I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE verification_error_reference ) ; insn_format20bc()10766 public final smaliParser.insn_format20bc_return insn_format20bc() throws RecognitionException { 10767 smaliParser.insn_format20bc_return retval = new smaliParser.insn_format20bc_return(); 10768 retval.start = input.LT(1); 10769 10770 CommonTree root_0 = null; 10771 10772 Token INSTRUCTION_FORMAT20bc307=null; 10773 Token VERIFICATION_ERROR_TYPE308=null; 10774 Token COMMA309=null; 10775 ParserRuleReturnScope verification_error_reference310 =null; 10776 10777 CommonTree INSTRUCTION_FORMAT20bc307_tree=null; 10778 CommonTree VERIFICATION_ERROR_TYPE308_tree=null; 10779 CommonTree COMMA309_tree=null; 10780 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT20bc=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT20bc"); 10781 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 10782 RewriteRuleTokenStream stream_VERIFICATION_ERROR_TYPE=new RewriteRuleTokenStream(adaptor,"token VERIFICATION_ERROR_TYPE"); 10783 RewriteRuleSubtreeStream stream_verification_error_reference=new RewriteRuleSubtreeStream(adaptor,"rule verification_error_reference"); 10784 10785 try { 10786 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:892:3: ( INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE COMMA verification_error_reference -> ^( I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE verification_error_reference ) ) 10787 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:893:5: INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE COMMA verification_error_reference 10788 { 10789 INSTRUCTION_FORMAT20bc307=(Token)match(input,INSTRUCTION_FORMAT20bc,FOLLOW_INSTRUCTION_FORMAT20bc_in_insn_format20bc4295); 10790 stream_INSTRUCTION_FORMAT20bc.add(INSTRUCTION_FORMAT20bc307); 10791 10792 VERIFICATION_ERROR_TYPE308=(Token)match(input,VERIFICATION_ERROR_TYPE,FOLLOW_VERIFICATION_ERROR_TYPE_in_insn_format20bc4297); 10793 stream_VERIFICATION_ERROR_TYPE.add(VERIFICATION_ERROR_TYPE308); 10794 10795 COMMA309=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format20bc4299); 10796 stream_COMMA.add(COMMA309); 10797 10798 pushFollow(FOLLOW_verification_error_reference_in_insn_format20bc4301); 10799 verification_error_reference310=verification_error_reference(); 10800 state._fsp--; 10801 10802 stream_verification_error_reference.add(verification_error_reference310.getTree()); 10803 10804 if (!allowOdex || opcodes.getOpcodeByName((INSTRUCTION_FORMAT20bc307!=null?INSTRUCTION_FORMAT20bc307.getText():null)) == null || apiLevel >= 14) { 10805 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT20bc307!=null?INSTRUCTION_FORMAT20bc307.getText():null)); 10806 } 10807 10808 // AST REWRITE 10809 // elements: verification_error_reference, INSTRUCTION_FORMAT20bc, VERIFICATION_ERROR_TYPE 10810 // token labels: 10811 // rule labels: retval 10812 // token list labels: 10813 // rule list labels: 10814 // wildcard labels: 10815 retval.tree = root_0; 10816 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10817 10818 root_0 = (CommonTree)adaptor.nil(); 10819 // 899:5: -> ^( I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE verification_error_reference ) 10820 { 10821 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:899:8: ^( I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE verification_error_reference ) 10822 { 10823 CommonTree root_1 = (CommonTree)adaptor.nil(); 10824 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT20bc, "I_STATEMENT_FORMAT20bc"), root_1); 10825 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT20bc.nextNode()); 10826 adaptor.addChild(root_1, stream_VERIFICATION_ERROR_TYPE.nextNode()); 10827 adaptor.addChild(root_1, stream_verification_error_reference.nextTree()); 10828 adaptor.addChild(root_0, root_1); 10829 } 10830 10831 } 10832 10833 10834 retval.tree = root_0; 10835 10836 } 10837 10838 retval.stop = input.LT(-1); 10839 10840 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10841 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10842 10843 } 10844 catch (RecognitionException re) { 10845 reportError(re); 10846 recover(input,re); 10847 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10848 } 10849 finally { 10850 // do for sure before leaving 10851 } 10852 return retval; 10853 } 10854 // $ANTLR end "insn_format20bc" 10855 10856 10857 public static class insn_format20t_return extends ParserRuleReturnScope { 10858 CommonTree tree; 10859 @Override getTree()10860 public CommonTree getTree() { return tree; } 10861 }; 10862 10863 10864 // $ANTLR start "insn_format20t" 10865 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:901:1: insn_format20t : INSTRUCTION_FORMAT20t label_ref -> ^( I_STATEMENT_FORMAT20t[$start, \"I_STATEMENT_FORMAT20t\"] INSTRUCTION_FORMAT20t label_ref ) ; insn_format20t()10866 public final smaliParser.insn_format20t_return insn_format20t() throws RecognitionException { 10867 smaliParser.insn_format20t_return retval = new smaliParser.insn_format20t_return(); 10868 retval.start = input.LT(1); 10869 10870 CommonTree root_0 = null; 10871 10872 Token INSTRUCTION_FORMAT20t311=null; 10873 ParserRuleReturnScope label_ref312 =null; 10874 10875 CommonTree INSTRUCTION_FORMAT20t311_tree=null; 10876 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT20t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT20t"); 10877 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 10878 10879 try { 10880 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:902:3: ( INSTRUCTION_FORMAT20t label_ref -> ^( I_STATEMENT_FORMAT20t[$start, \"I_STATEMENT_FORMAT20t\"] INSTRUCTION_FORMAT20t label_ref ) ) 10881 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:903:5: INSTRUCTION_FORMAT20t label_ref 10882 { 10883 INSTRUCTION_FORMAT20t311=(Token)match(input,INSTRUCTION_FORMAT20t,FOLLOW_INSTRUCTION_FORMAT20t_in_insn_format20t4338); 10884 stream_INSTRUCTION_FORMAT20t.add(INSTRUCTION_FORMAT20t311); 10885 10886 pushFollow(FOLLOW_label_ref_in_insn_format20t4340); 10887 label_ref312=label_ref(); 10888 state._fsp--; 10889 10890 stream_label_ref.add(label_ref312.getTree()); 10891 // AST REWRITE 10892 // elements: INSTRUCTION_FORMAT20t, label_ref 10893 // token labels: 10894 // rule labels: retval 10895 // token list labels: 10896 // rule list labels: 10897 // wildcard labels: 10898 retval.tree = root_0; 10899 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10900 10901 root_0 = (CommonTree)adaptor.nil(); 10902 // 904:5: -> ^( I_STATEMENT_FORMAT20t[$start, \"I_STATEMENT_FORMAT20t\"] INSTRUCTION_FORMAT20t label_ref ) 10903 { 10904 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:904:8: ^( I_STATEMENT_FORMAT20t[$start, \"I_STATEMENT_FORMAT20t\"] INSTRUCTION_FORMAT20t label_ref ) 10905 { 10906 CommonTree root_1 = (CommonTree)adaptor.nil(); 10907 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT20t, (retval.start), "I_STATEMENT_FORMAT20t"), root_1); 10908 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT20t.nextNode()); 10909 adaptor.addChild(root_1, stream_label_ref.nextTree()); 10910 adaptor.addChild(root_0, root_1); 10911 } 10912 10913 } 10914 10915 10916 retval.tree = root_0; 10917 10918 } 10919 10920 retval.stop = input.LT(-1); 10921 10922 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10923 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10924 10925 } 10926 catch (RecognitionException re) { 10927 reportError(re); 10928 recover(input,re); 10929 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10930 } 10931 finally { 10932 // do for sure before leaving 10933 } 10934 return retval; 10935 } 10936 // $ANTLR end "insn_format20t" 10937 10938 10939 public static class insn_format21c_field_return extends ParserRuleReturnScope { 10940 CommonTree tree; 10941 @Override getTree()10942 public CommonTree getTree() { return tree; } 10943 }; 10944 10945 10946 // $ANTLR start "insn_format21c_field" 10947 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:906: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 ) ; insn_format21c_field()10948 public final smaliParser.insn_format21c_field_return insn_format21c_field() throws RecognitionException { 10949 smaliParser.insn_format21c_field_return retval = new smaliParser.insn_format21c_field_return(); 10950 retval.start = input.LT(1); 10951 10952 CommonTree root_0 = null; 10953 10954 Token INSTRUCTION_FORMAT21c_FIELD313=null; 10955 Token REGISTER314=null; 10956 Token COMMA315=null; 10957 ParserRuleReturnScope field_reference316 =null; 10958 10959 CommonTree INSTRUCTION_FORMAT21c_FIELD313_tree=null; 10960 CommonTree REGISTER314_tree=null; 10961 CommonTree COMMA315_tree=null; 10962 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 10963 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_FIELD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_FIELD"); 10964 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 10965 RewriteRuleSubtreeStream stream_field_reference=new RewriteRuleSubtreeStream(adaptor,"rule field_reference"); 10966 10967 try { 10968 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:907:3: ( INSTRUCTION_FORMAT21c_FIELD REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD REGISTER field_reference ) ) 10969 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:908:5: INSTRUCTION_FORMAT21c_FIELD REGISTER COMMA field_reference 10970 { 10971 INSTRUCTION_FORMAT21c_FIELD313=(Token)match(input,INSTRUCTION_FORMAT21c_FIELD,FOLLOW_INSTRUCTION_FORMAT21c_FIELD_in_insn_format21c_field4370); 10972 stream_INSTRUCTION_FORMAT21c_FIELD.add(INSTRUCTION_FORMAT21c_FIELD313); 10973 10974 REGISTER314=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_field4372); 10975 stream_REGISTER.add(REGISTER314); 10976 10977 COMMA315=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21c_field4374); 10978 stream_COMMA.add(COMMA315); 10979 10980 pushFollow(FOLLOW_field_reference_in_insn_format21c_field4376); 10981 field_reference316=field_reference(); 10982 state._fsp--; 10983 10984 stream_field_reference.add(field_reference316.getTree()); 10985 // AST REWRITE 10986 // elements: REGISTER, field_reference, INSTRUCTION_FORMAT21c_FIELD 10987 // token labels: 10988 // rule labels: retval 10989 // token list labels: 10990 // rule list labels: 10991 // wildcard labels: 10992 retval.tree = root_0; 10993 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10994 10995 root_0 = (CommonTree)adaptor.nil(); 10996 // 909:5: -> ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD REGISTER field_reference ) 10997 { 10998 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:909:8: ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD REGISTER field_reference ) 10999 { 11000 CommonTree root_1 = (CommonTree)adaptor.nil(); 11001 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21c_FIELD, (retval.start), "I_STATEMENT_FORMAT21c_FIELD"), root_1); 11002 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21c_FIELD.nextNode()); 11003 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11004 adaptor.addChild(root_1, stream_field_reference.nextTree()); 11005 adaptor.addChild(root_0, root_1); 11006 } 11007 11008 } 11009 11010 11011 retval.tree = root_0; 11012 11013 } 11014 11015 retval.stop = input.LT(-1); 11016 11017 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11018 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11019 11020 } 11021 catch (RecognitionException re) { 11022 reportError(re); 11023 recover(input,re); 11024 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11025 } 11026 finally { 11027 // do for sure before leaving 11028 } 11029 return retval; 11030 } 11031 // $ANTLR end "insn_format21c_field" 11032 11033 11034 public static class insn_format21c_field_odex_return extends ParserRuleReturnScope { 11035 CommonTree tree; 11036 @Override getTree()11037 public CommonTree getTree() { return tree; } 11038 }; 11039 11040 11041 // $ANTLR start "insn_format21c_field_odex" 11042 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:911: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 ) ; insn_format21c_field_odex()11043 public final smaliParser.insn_format21c_field_odex_return insn_format21c_field_odex() throws RecognitionException { 11044 smaliParser.insn_format21c_field_odex_return retval = new smaliParser.insn_format21c_field_odex_return(); 11045 retval.start = input.LT(1); 11046 11047 CommonTree root_0 = null; 11048 11049 Token INSTRUCTION_FORMAT21c_FIELD_ODEX317=null; 11050 Token REGISTER318=null; 11051 Token COMMA319=null; 11052 ParserRuleReturnScope field_reference320 =null; 11053 11054 CommonTree INSTRUCTION_FORMAT21c_FIELD_ODEX317_tree=null; 11055 CommonTree REGISTER318_tree=null; 11056 CommonTree COMMA319_tree=null; 11057 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11058 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11059 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_FIELD_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_FIELD_ODEX"); 11060 RewriteRuleSubtreeStream stream_field_reference=new RewriteRuleSubtreeStream(adaptor,"rule field_reference"); 11061 11062 try { 11063 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:912: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 ) ) 11064 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:913:5: INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER COMMA field_reference 11065 { 11066 INSTRUCTION_FORMAT21c_FIELD_ODEX317=(Token)match(input,INSTRUCTION_FORMAT21c_FIELD_ODEX,FOLLOW_INSTRUCTION_FORMAT21c_FIELD_ODEX_in_insn_format21c_field_odex4408); 11067 stream_INSTRUCTION_FORMAT21c_FIELD_ODEX.add(INSTRUCTION_FORMAT21c_FIELD_ODEX317); 11068 11069 REGISTER318=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_field_odex4410); 11070 stream_REGISTER.add(REGISTER318); 11071 11072 COMMA319=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21c_field_odex4412); 11073 stream_COMMA.add(COMMA319); 11074 11075 pushFollow(FOLLOW_field_reference_in_insn_format21c_field_odex4414); 11076 field_reference320=field_reference(); 11077 state._fsp--; 11078 11079 stream_field_reference.add(field_reference320.getTree()); 11080 11081 if (!allowOdex || opcodes.getOpcodeByName((INSTRUCTION_FORMAT21c_FIELD_ODEX317!=null?INSTRUCTION_FORMAT21c_FIELD_ODEX317.getText():null)) == null || apiLevel >= 14) { 11082 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT21c_FIELD_ODEX317!=null?INSTRUCTION_FORMAT21c_FIELD_ODEX317.getText():null)); 11083 } 11084 11085 // AST REWRITE 11086 // elements: field_reference, INSTRUCTION_FORMAT21c_FIELD_ODEX, REGISTER 11087 // token labels: 11088 // rule labels: retval 11089 // token list labels: 11090 // rule list labels: 11091 // wildcard labels: 11092 retval.tree = root_0; 11093 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11094 11095 root_0 = (CommonTree)adaptor.nil(); 11096 // 919:5: -> ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER field_reference ) 11097 { 11098 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:919:8: ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER field_reference ) 11099 { 11100 CommonTree root_1 = (CommonTree)adaptor.nil(); 11101 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21c_FIELD, (retval.start), "I_STATEMENT_FORMAT21c_FIELD"), root_1); 11102 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21c_FIELD_ODEX.nextNode()); 11103 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11104 adaptor.addChild(root_1, stream_field_reference.nextTree()); 11105 adaptor.addChild(root_0, root_1); 11106 } 11107 11108 } 11109 11110 11111 retval.tree = root_0; 11112 11113 } 11114 11115 retval.stop = input.LT(-1); 11116 11117 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11118 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11119 11120 } 11121 catch (RecognitionException re) { 11122 reportError(re); 11123 recover(input,re); 11124 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11125 } 11126 finally { 11127 // do for sure before leaving 11128 } 11129 return retval; 11130 } 11131 // $ANTLR end "insn_format21c_field_odex" 11132 11133 11134 public static class insn_format21c_string_return extends ParserRuleReturnScope { 11135 CommonTree tree; 11136 @Override getTree()11137 public CommonTree getTree() { return tree; } 11138 }; 11139 11140 11141 // $ANTLR start "insn_format21c_string" 11142 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:921: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 ) ; insn_format21c_string()11143 public final smaliParser.insn_format21c_string_return insn_format21c_string() throws RecognitionException { 11144 smaliParser.insn_format21c_string_return retval = new smaliParser.insn_format21c_string_return(); 11145 retval.start = input.LT(1); 11146 11147 CommonTree root_0 = null; 11148 11149 Token INSTRUCTION_FORMAT21c_STRING321=null; 11150 Token REGISTER322=null; 11151 Token COMMA323=null; 11152 Token STRING_LITERAL324=null; 11153 11154 CommonTree INSTRUCTION_FORMAT21c_STRING321_tree=null; 11155 CommonTree REGISTER322_tree=null; 11156 CommonTree COMMA323_tree=null; 11157 CommonTree STRING_LITERAL324_tree=null; 11158 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_STRING=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_STRING"); 11159 RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL"); 11160 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11161 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11162 11163 try { 11164 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:922:3: ( INSTRUCTION_FORMAT21c_STRING REGISTER COMMA STRING_LITERAL -> ^( I_STATEMENT_FORMAT21c_STRING[$start, \"I_STATEMENT_FORMAT21c_STRING\"] INSTRUCTION_FORMAT21c_STRING REGISTER STRING_LITERAL ) ) 11165 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:923:5: INSTRUCTION_FORMAT21c_STRING REGISTER COMMA STRING_LITERAL 11166 { 11167 INSTRUCTION_FORMAT21c_STRING321=(Token)match(input,INSTRUCTION_FORMAT21c_STRING,FOLLOW_INSTRUCTION_FORMAT21c_STRING_in_insn_format21c_string4452); 11168 stream_INSTRUCTION_FORMAT21c_STRING.add(INSTRUCTION_FORMAT21c_STRING321); 11169 11170 REGISTER322=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_string4454); 11171 stream_REGISTER.add(REGISTER322); 11172 11173 COMMA323=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21c_string4456); 11174 stream_COMMA.add(COMMA323); 11175 11176 STRING_LITERAL324=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_insn_format21c_string4458); 11177 stream_STRING_LITERAL.add(STRING_LITERAL324); 11178 11179 // AST REWRITE 11180 // elements: INSTRUCTION_FORMAT21c_STRING, REGISTER, STRING_LITERAL 11181 // token labels: 11182 // rule labels: retval 11183 // token list labels: 11184 // rule list labels: 11185 // wildcard labels: 11186 retval.tree = root_0; 11187 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11188 11189 root_0 = (CommonTree)adaptor.nil(); 11190 // 924:5: -> ^( I_STATEMENT_FORMAT21c_STRING[$start, \"I_STATEMENT_FORMAT21c_STRING\"] INSTRUCTION_FORMAT21c_STRING REGISTER STRING_LITERAL ) 11191 { 11192 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:924:8: ^( I_STATEMENT_FORMAT21c_STRING[$start, \"I_STATEMENT_FORMAT21c_STRING\"] INSTRUCTION_FORMAT21c_STRING REGISTER STRING_LITERAL ) 11193 { 11194 CommonTree root_1 = (CommonTree)adaptor.nil(); 11195 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21c_STRING, (retval.start), "I_STATEMENT_FORMAT21c_STRING"), root_1); 11196 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21c_STRING.nextNode()); 11197 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11198 adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode()); 11199 adaptor.addChild(root_0, root_1); 11200 } 11201 11202 } 11203 11204 11205 retval.tree = root_0; 11206 11207 } 11208 11209 retval.stop = input.LT(-1); 11210 11211 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11212 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11213 11214 } 11215 catch (RecognitionException re) { 11216 reportError(re); 11217 recover(input,re); 11218 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11219 } 11220 finally { 11221 // do for sure before leaving 11222 } 11223 return retval; 11224 } 11225 // $ANTLR end "insn_format21c_string" 11226 11227 11228 public static class insn_format21c_type_return extends ParserRuleReturnScope { 11229 CommonTree tree; 11230 @Override getTree()11231 public CommonTree getTree() { return tree; } 11232 }; 11233 11234 11235 // $ANTLR start "insn_format21c_type" 11236 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:926: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 ) ; insn_format21c_type()11237 public final smaliParser.insn_format21c_type_return insn_format21c_type() throws RecognitionException { 11238 smaliParser.insn_format21c_type_return retval = new smaliParser.insn_format21c_type_return(); 11239 retval.start = input.LT(1); 11240 11241 CommonTree root_0 = null; 11242 11243 Token INSTRUCTION_FORMAT21c_TYPE325=null; 11244 Token REGISTER326=null; 11245 Token COMMA327=null; 11246 ParserRuleReturnScope nonvoid_type_descriptor328 =null; 11247 11248 CommonTree INSTRUCTION_FORMAT21c_TYPE325_tree=null; 11249 CommonTree REGISTER326_tree=null; 11250 CommonTree COMMA327_tree=null; 11251 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11252 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_TYPE"); 11253 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11254 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 11255 11256 try { 11257 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:927:3: ( INSTRUCTION_FORMAT21c_TYPE REGISTER COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT21c_TYPE[$start, \"I_STATEMENT_FORMAT21c\"] INSTRUCTION_FORMAT21c_TYPE REGISTER nonvoid_type_descriptor ) ) 11258 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:928:5: INSTRUCTION_FORMAT21c_TYPE REGISTER COMMA nonvoid_type_descriptor 11259 { 11260 INSTRUCTION_FORMAT21c_TYPE325=(Token)match(input,INSTRUCTION_FORMAT21c_TYPE,FOLLOW_INSTRUCTION_FORMAT21c_TYPE_in_insn_format21c_type4490); 11261 stream_INSTRUCTION_FORMAT21c_TYPE.add(INSTRUCTION_FORMAT21c_TYPE325); 11262 11263 REGISTER326=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_type4492); 11264 stream_REGISTER.add(REGISTER326); 11265 11266 COMMA327=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21c_type4494); 11267 stream_COMMA.add(COMMA327); 11268 11269 pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format21c_type4496); 11270 nonvoid_type_descriptor328=nonvoid_type_descriptor(); 11271 state._fsp--; 11272 11273 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor328.getTree()); 11274 // AST REWRITE 11275 // elements: REGISTER, nonvoid_type_descriptor, INSTRUCTION_FORMAT21c_TYPE 11276 // token labels: 11277 // rule labels: retval 11278 // token list labels: 11279 // rule list labels: 11280 // wildcard labels: 11281 retval.tree = root_0; 11282 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11283 11284 root_0 = (CommonTree)adaptor.nil(); 11285 // 929:5: -> ^( I_STATEMENT_FORMAT21c_TYPE[$start, \"I_STATEMENT_FORMAT21c\"] INSTRUCTION_FORMAT21c_TYPE REGISTER nonvoid_type_descriptor ) 11286 { 11287 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:929:8: ^( I_STATEMENT_FORMAT21c_TYPE[$start, \"I_STATEMENT_FORMAT21c\"] INSTRUCTION_FORMAT21c_TYPE REGISTER nonvoid_type_descriptor ) 11288 { 11289 CommonTree root_1 = (CommonTree)adaptor.nil(); 11290 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21c_TYPE, (retval.start), "I_STATEMENT_FORMAT21c"), root_1); 11291 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21c_TYPE.nextNode()); 11292 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11293 adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree()); 11294 adaptor.addChild(root_0, root_1); 11295 } 11296 11297 } 11298 11299 11300 retval.tree = root_0; 11301 11302 } 11303 11304 retval.stop = input.LT(-1); 11305 11306 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11307 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11308 11309 } 11310 catch (RecognitionException re) { 11311 reportError(re); 11312 recover(input,re); 11313 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11314 } 11315 finally { 11316 // do for sure before leaving 11317 } 11318 return retval; 11319 } 11320 // $ANTLR end "insn_format21c_type" 11321 11322 11323 public static class insn_format21c_lambda_return extends ParserRuleReturnScope { 11324 CommonTree tree; 11325 @Override getTree()11326 public CommonTree getTree() { return tree; } 11327 }; 11328 11329 11330 // $ANTLR start "insn_format21c_lambda" 11331 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:931:1: insn_format21c_lambda : INSTRUCTION_FORMAT21c_LAMBDA REGISTER COMMA STRING_LITERAL -> ^( I_STATEMENT_FORMAT21c_LAMBDA[$start, \"I_STATEMENT_FORMAT21c_LAMBDA\"] INSTRUCTION_FORMAT21c_LAMBDA REGISTER STRING_LITERAL ) ; insn_format21c_lambda()11332 public final smaliParser.insn_format21c_lambda_return insn_format21c_lambda() throws RecognitionException { 11333 smaliParser.insn_format21c_lambda_return retval = new smaliParser.insn_format21c_lambda_return(); 11334 retval.start = input.LT(1); 11335 11336 CommonTree root_0 = null; 11337 11338 Token INSTRUCTION_FORMAT21c_LAMBDA329=null; 11339 Token REGISTER330=null; 11340 Token COMMA331=null; 11341 Token STRING_LITERAL332=null; 11342 11343 CommonTree INSTRUCTION_FORMAT21c_LAMBDA329_tree=null; 11344 CommonTree REGISTER330_tree=null; 11345 CommonTree COMMA331_tree=null; 11346 CommonTree STRING_LITERAL332_tree=null; 11347 RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL"); 11348 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_LAMBDA=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_LAMBDA"); 11349 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11350 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11351 11352 try { 11353 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:932:3: ( INSTRUCTION_FORMAT21c_LAMBDA REGISTER COMMA STRING_LITERAL -> ^( I_STATEMENT_FORMAT21c_LAMBDA[$start, \"I_STATEMENT_FORMAT21c_LAMBDA\"] INSTRUCTION_FORMAT21c_LAMBDA REGISTER STRING_LITERAL ) ) 11354 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:933:5: INSTRUCTION_FORMAT21c_LAMBDA REGISTER COMMA STRING_LITERAL 11355 { 11356 INSTRUCTION_FORMAT21c_LAMBDA329=(Token)match(input,INSTRUCTION_FORMAT21c_LAMBDA,FOLLOW_INSTRUCTION_FORMAT21c_LAMBDA_in_insn_format21c_lambda4528); 11357 stream_INSTRUCTION_FORMAT21c_LAMBDA.add(INSTRUCTION_FORMAT21c_LAMBDA329); 11358 11359 REGISTER330=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_lambda4530); 11360 stream_REGISTER.add(REGISTER330); 11361 11362 COMMA331=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21c_lambda4532); 11363 stream_COMMA.add(COMMA331); 11364 11365 STRING_LITERAL332=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_insn_format21c_lambda4534); 11366 stream_STRING_LITERAL.add(STRING_LITERAL332); 11367 11368 // AST REWRITE 11369 // elements: REGISTER, STRING_LITERAL, INSTRUCTION_FORMAT21c_LAMBDA 11370 // token labels: 11371 // rule labels: retval 11372 // token list labels: 11373 // rule list labels: 11374 // wildcard labels: 11375 retval.tree = root_0; 11376 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11377 11378 root_0 = (CommonTree)adaptor.nil(); 11379 // 934:5: -> ^( I_STATEMENT_FORMAT21c_LAMBDA[$start, \"I_STATEMENT_FORMAT21c_LAMBDA\"] INSTRUCTION_FORMAT21c_LAMBDA REGISTER STRING_LITERAL ) 11380 { 11381 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:934:8: ^( I_STATEMENT_FORMAT21c_LAMBDA[$start, \"I_STATEMENT_FORMAT21c_LAMBDA\"] INSTRUCTION_FORMAT21c_LAMBDA REGISTER STRING_LITERAL ) 11382 { 11383 CommonTree root_1 = (CommonTree)adaptor.nil(); 11384 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21c_LAMBDA, (retval.start), "I_STATEMENT_FORMAT21c_LAMBDA"), root_1); 11385 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21c_LAMBDA.nextNode()); 11386 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11387 adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode()); 11388 adaptor.addChild(root_0, root_1); 11389 } 11390 11391 } 11392 11393 11394 retval.tree = root_0; 11395 11396 } 11397 11398 retval.stop = input.LT(-1); 11399 11400 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11401 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11402 11403 } 11404 catch (RecognitionException re) { 11405 reportError(re); 11406 recover(input,re); 11407 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11408 } 11409 finally { 11410 // do for sure before leaving 11411 } 11412 return retval; 11413 } 11414 // $ANTLR end "insn_format21c_lambda" 11415 11416 11417 public static class insn_format21c_method_return extends ParserRuleReturnScope { 11418 CommonTree tree; 11419 @Override getTree()11420 public CommonTree getTree() { return tree; } 11421 }; 11422 11423 11424 // $ANTLR start "insn_format21c_method" 11425 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:936:1: insn_format21c_method : INSTRUCTION_FORMAT21c_METHOD REGISTER COMMA method_reference -> ^( I_STATEMENT_FORMAT21c_METHOD[$start, \"I_STATEMENT_FORMAT21c_METHOD\"] INSTRUCTION_FORMAT21c_METHOD REGISTER method_reference ) ; insn_format21c_method()11426 public final smaliParser.insn_format21c_method_return insn_format21c_method() throws RecognitionException { 11427 smaliParser.insn_format21c_method_return retval = new smaliParser.insn_format21c_method_return(); 11428 retval.start = input.LT(1); 11429 11430 CommonTree root_0 = null; 11431 11432 Token INSTRUCTION_FORMAT21c_METHOD333=null; 11433 Token REGISTER334=null; 11434 Token COMMA335=null; 11435 ParserRuleReturnScope method_reference336 =null; 11436 11437 CommonTree INSTRUCTION_FORMAT21c_METHOD333_tree=null; 11438 CommonTree REGISTER334_tree=null; 11439 CommonTree COMMA335_tree=null; 11440 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11441 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11442 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_METHOD"); 11443 RewriteRuleSubtreeStream stream_method_reference=new RewriteRuleSubtreeStream(adaptor,"rule method_reference"); 11444 11445 try { 11446 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:937:3: ( INSTRUCTION_FORMAT21c_METHOD REGISTER COMMA method_reference -> ^( I_STATEMENT_FORMAT21c_METHOD[$start, \"I_STATEMENT_FORMAT21c_METHOD\"] INSTRUCTION_FORMAT21c_METHOD REGISTER method_reference ) ) 11447 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:938:5: INSTRUCTION_FORMAT21c_METHOD REGISTER COMMA method_reference 11448 { 11449 INSTRUCTION_FORMAT21c_METHOD333=(Token)match(input,INSTRUCTION_FORMAT21c_METHOD,FOLLOW_INSTRUCTION_FORMAT21c_METHOD_in_insn_format21c_method4566); 11450 stream_INSTRUCTION_FORMAT21c_METHOD.add(INSTRUCTION_FORMAT21c_METHOD333); 11451 11452 REGISTER334=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_method4568); 11453 stream_REGISTER.add(REGISTER334); 11454 11455 COMMA335=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21c_method4570); 11456 stream_COMMA.add(COMMA335); 11457 11458 pushFollow(FOLLOW_method_reference_in_insn_format21c_method4572); 11459 method_reference336=method_reference(); 11460 state._fsp--; 11461 11462 stream_method_reference.add(method_reference336.getTree()); 11463 // AST REWRITE 11464 // elements: REGISTER, INSTRUCTION_FORMAT21c_METHOD, method_reference 11465 // token labels: 11466 // rule labels: retval 11467 // token list labels: 11468 // rule list labels: 11469 // wildcard labels: 11470 retval.tree = root_0; 11471 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11472 11473 root_0 = (CommonTree)adaptor.nil(); 11474 // 939:5: -> ^( I_STATEMENT_FORMAT21c_METHOD[$start, \"I_STATEMENT_FORMAT21c_METHOD\"] INSTRUCTION_FORMAT21c_METHOD REGISTER method_reference ) 11475 { 11476 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:939:8: ^( I_STATEMENT_FORMAT21c_METHOD[$start, \"I_STATEMENT_FORMAT21c_METHOD\"] INSTRUCTION_FORMAT21c_METHOD REGISTER method_reference ) 11477 { 11478 CommonTree root_1 = (CommonTree)adaptor.nil(); 11479 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21c_METHOD, (retval.start), "I_STATEMENT_FORMAT21c_METHOD"), root_1); 11480 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21c_METHOD.nextNode()); 11481 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11482 adaptor.addChild(root_1, stream_method_reference.nextTree()); 11483 adaptor.addChild(root_0, root_1); 11484 } 11485 11486 } 11487 11488 11489 retval.tree = root_0; 11490 11491 } 11492 11493 retval.stop = input.LT(-1); 11494 11495 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11496 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11497 11498 } 11499 catch (RecognitionException re) { 11500 reportError(re); 11501 recover(input,re); 11502 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11503 } 11504 finally { 11505 // do for sure before leaving 11506 } 11507 return retval; 11508 } 11509 // $ANTLR end "insn_format21c_method" 11510 11511 11512 public static class insn_format21ih_return extends ParserRuleReturnScope { 11513 CommonTree tree; 11514 @Override getTree()11515 public CommonTree getTree() { return tree; } 11516 }; 11517 11518 11519 // $ANTLR start "insn_format21ih" 11520 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:941:1: insn_format21ih : INSTRUCTION_FORMAT21ih REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT21ih[$start, \"I_STATEMENT_FORMAT21ih\"] INSTRUCTION_FORMAT21ih REGISTER fixed_32bit_literal ) ; insn_format21ih()11521 public final smaliParser.insn_format21ih_return insn_format21ih() throws RecognitionException { 11522 smaliParser.insn_format21ih_return retval = new smaliParser.insn_format21ih_return(); 11523 retval.start = input.LT(1); 11524 11525 CommonTree root_0 = null; 11526 11527 Token INSTRUCTION_FORMAT21ih337=null; 11528 Token REGISTER338=null; 11529 Token COMMA339=null; 11530 ParserRuleReturnScope fixed_32bit_literal340 =null; 11531 11532 CommonTree INSTRUCTION_FORMAT21ih337_tree=null; 11533 CommonTree REGISTER338_tree=null; 11534 CommonTree COMMA339_tree=null; 11535 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21ih=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21ih"); 11536 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11537 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11538 RewriteRuleSubtreeStream stream_fixed_32bit_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_32bit_literal"); 11539 11540 try { 11541 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:942:3: ( INSTRUCTION_FORMAT21ih REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT21ih[$start, \"I_STATEMENT_FORMAT21ih\"] INSTRUCTION_FORMAT21ih REGISTER fixed_32bit_literal ) ) 11542 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:943:5: INSTRUCTION_FORMAT21ih REGISTER COMMA fixed_32bit_literal 11543 { 11544 INSTRUCTION_FORMAT21ih337=(Token)match(input,INSTRUCTION_FORMAT21ih,FOLLOW_INSTRUCTION_FORMAT21ih_in_insn_format21ih4604); 11545 stream_INSTRUCTION_FORMAT21ih.add(INSTRUCTION_FORMAT21ih337); 11546 11547 REGISTER338=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21ih4606); 11548 stream_REGISTER.add(REGISTER338); 11549 11550 COMMA339=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21ih4608); 11551 stream_COMMA.add(COMMA339); 11552 11553 pushFollow(FOLLOW_fixed_32bit_literal_in_insn_format21ih4610); 11554 fixed_32bit_literal340=fixed_32bit_literal(); 11555 state._fsp--; 11556 11557 stream_fixed_32bit_literal.add(fixed_32bit_literal340.getTree()); 11558 // AST REWRITE 11559 // elements: INSTRUCTION_FORMAT21ih, fixed_32bit_literal, REGISTER 11560 // token labels: 11561 // rule labels: retval 11562 // token list labels: 11563 // rule list labels: 11564 // wildcard labels: 11565 retval.tree = root_0; 11566 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11567 11568 root_0 = (CommonTree)adaptor.nil(); 11569 // 944:5: -> ^( I_STATEMENT_FORMAT21ih[$start, \"I_STATEMENT_FORMAT21ih\"] INSTRUCTION_FORMAT21ih REGISTER fixed_32bit_literal ) 11570 { 11571 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:944:8: ^( I_STATEMENT_FORMAT21ih[$start, \"I_STATEMENT_FORMAT21ih\"] INSTRUCTION_FORMAT21ih REGISTER fixed_32bit_literal ) 11572 { 11573 CommonTree root_1 = (CommonTree)adaptor.nil(); 11574 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21ih, (retval.start), "I_STATEMENT_FORMAT21ih"), root_1); 11575 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21ih.nextNode()); 11576 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11577 adaptor.addChild(root_1, stream_fixed_32bit_literal.nextTree()); 11578 adaptor.addChild(root_0, root_1); 11579 } 11580 11581 } 11582 11583 11584 retval.tree = root_0; 11585 11586 } 11587 11588 retval.stop = input.LT(-1); 11589 11590 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11591 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11592 11593 } 11594 catch (RecognitionException re) { 11595 reportError(re); 11596 recover(input,re); 11597 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11598 } 11599 finally { 11600 // do for sure before leaving 11601 } 11602 return retval; 11603 } 11604 // $ANTLR end "insn_format21ih" 11605 11606 11607 public static class insn_format21lh_return extends ParserRuleReturnScope { 11608 CommonTree tree; 11609 @Override getTree()11610 public CommonTree getTree() { return tree; } 11611 }; 11612 11613 11614 // $ANTLR start "insn_format21lh" 11615 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:946:1: insn_format21lh : INSTRUCTION_FORMAT21lh REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT21lh[$start, \"I_STATEMENT_FORMAT21lh\"] INSTRUCTION_FORMAT21lh REGISTER fixed_32bit_literal ) ; insn_format21lh()11616 public final smaliParser.insn_format21lh_return insn_format21lh() throws RecognitionException { 11617 smaliParser.insn_format21lh_return retval = new smaliParser.insn_format21lh_return(); 11618 retval.start = input.LT(1); 11619 11620 CommonTree root_0 = null; 11621 11622 Token INSTRUCTION_FORMAT21lh341=null; 11623 Token REGISTER342=null; 11624 Token COMMA343=null; 11625 ParserRuleReturnScope fixed_32bit_literal344 =null; 11626 11627 CommonTree INSTRUCTION_FORMAT21lh341_tree=null; 11628 CommonTree REGISTER342_tree=null; 11629 CommonTree COMMA343_tree=null; 11630 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21lh=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21lh"); 11631 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11632 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11633 RewriteRuleSubtreeStream stream_fixed_32bit_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_32bit_literal"); 11634 11635 try { 11636 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:947:3: ( INSTRUCTION_FORMAT21lh REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT21lh[$start, \"I_STATEMENT_FORMAT21lh\"] INSTRUCTION_FORMAT21lh REGISTER fixed_32bit_literal ) ) 11637 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:948:5: INSTRUCTION_FORMAT21lh REGISTER COMMA fixed_32bit_literal 11638 { 11639 INSTRUCTION_FORMAT21lh341=(Token)match(input,INSTRUCTION_FORMAT21lh,FOLLOW_INSTRUCTION_FORMAT21lh_in_insn_format21lh4642); 11640 stream_INSTRUCTION_FORMAT21lh.add(INSTRUCTION_FORMAT21lh341); 11641 11642 REGISTER342=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21lh4644); 11643 stream_REGISTER.add(REGISTER342); 11644 11645 COMMA343=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21lh4646); 11646 stream_COMMA.add(COMMA343); 11647 11648 pushFollow(FOLLOW_fixed_32bit_literal_in_insn_format21lh4648); 11649 fixed_32bit_literal344=fixed_32bit_literal(); 11650 state._fsp--; 11651 11652 stream_fixed_32bit_literal.add(fixed_32bit_literal344.getTree()); 11653 // AST REWRITE 11654 // elements: fixed_32bit_literal, INSTRUCTION_FORMAT21lh, REGISTER 11655 // token labels: 11656 // rule labels: retval 11657 // token list labels: 11658 // rule list labels: 11659 // wildcard labels: 11660 retval.tree = root_0; 11661 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11662 11663 root_0 = (CommonTree)adaptor.nil(); 11664 // 949:5: -> ^( I_STATEMENT_FORMAT21lh[$start, \"I_STATEMENT_FORMAT21lh\"] INSTRUCTION_FORMAT21lh REGISTER fixed_32bit_literal ) 11665 { 11666 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:949:8: ^( I_STATEMENT_FORMAT21lh[$start, \"I_STATEMENT_FORMAT21lh\"] INSTRUCTION_FORMAT21lh REGISTER fixed_32bit_literal ) 11667 { 11668 CommonTree root_1 = (CommonTree)adaptor.nil(); 11669 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21lh, (retval.start), "I_STATEMENT_FORMAT21lh"), root_1); 11670 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21lh.nextNode()); 11671 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11672 adaptor.addChild(root_1, stream_fixed_32bit_literal.nextTree()); 11673 adaptor.addChild(root_0, root_1); 11674 } 11675 11676 } 11677 11678 11679 retval.tree = root_0; 11680 11681 } 11682 11683 retval.stop = input.LT(-1); 11684 11685 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11686 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11687 11688 } 11689 catch (RecognitionException re) { 11690 reportError(re); 11691 recover(input,re); 11692 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11693 } 11694 finally { 11695 // do for sure before leaving 11696 } 11697 return retval; 11698 } 11699 // $ANTLR end "insn_format21lh" 11700 11701 11702 public static class insn_format21s_return extends ParserRuleReturnScope { 11703 CommonTree tree; 11704 @Override getTree()11705 public CommonTree getTree() { return tree; } 11706 }; 11707 11708 11709 // $ANTLR start "insn_format21s" 11710 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:951:1: insn_format21s : INSTRUCTION_FORMAT21s REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT21s[$start, \"I_STATEMENT_FORMAT21s\"] INSTRUCTION_FORMAT21s REGISTER integral_literal ) ; insn_format21s()11711 public final smaliParser.insn_format21s_return insn_format21s() throws RecognitionException { 11712 smaliParser.insn_format21s_return retval = new smaliParser.insn_format21s_return(); 11713 retval.start = input.LT(1); 11714 11715 CommonTree root_0 = null; 11716 11717 Token INSTRUCTION_FORMAT21s345=null; 11718 Token REGISTER346=null; 11719 Token COMMA347=null; 11720 ParserRuleReturnScope integral_literal348 =null; 11721 11722 CommonTree INSTRUCTION_FORMAT21s345_tree=null; 11723 CommonTree REGISTER346_tree=null; 11724 CommonTree COMMA347_tree=null; 11725 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21s=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21s"); 11726 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11727 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11728 RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal"); 11729 11730 try { 11731 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:952:3: ( INSTRUCTION_FORMAT21s REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT21s[$start, \"I_STATEMENT_FORMAT21s\"] INSTRUCTION_FORMAT21s REGISTER integral_literal ) ) 11732 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:953:5: INSTRUCTION_FORMAT21s REGISTER COMMA integral_literal 11733 { 11734 INSTRUCTION_FORMAT21s345=(Token)match(input,INSTRUCTION_FORMAT21s,FOLLOW_INSTRUCTION_FORMAT21s_in_insn_format21s4680); 11735 stream_INSTRUCTION_FORMAT21s.add(INSTRUCTION_FORMAT21s345); 11736 11737 REGISTER346=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21s4682); 11738 stream_REGISTER.add(REGISTER346); 11739 11740 COMMA347=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21s4684); 11741 stream_COMMA.add(COMMA347); 11742 11743 pushFollow(FOLLOW_integral_literal_in_insn_format21s4686); 11744 integral_literal348=integral_literal(); 11745 state._fsp--; 11746 11747 stream_integral_literal.add(integral_literal348.getTree()); 11748 // AST REWRITE 11749 // elements: INSTRUCTION_FORMAT21s, REGISTER, integral_literal 11750 // token labels: 11751 // rule labels: retval 11752 // token list labels: 11753 // rule list labels: 11754 // wildcard labels: 11755 retval.tree = root_0; 11756 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11757 11758 root_0 = (CommonTree)adaptor.nil(); 11759 // 954:5: -> ^( I_STATEMENT_FORMAT21s[$start, \"I_STATEMENT_FORMAT21s\"] INSTRUCTION_FORMAT21s REGISTER integral_literal ) 11760 { 11761 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:954:8: ^( I_STATEMENT_FORMAT21s[$start, \"I_STATEMENT_FORMAT21s\"] INSTRUCTION_FORMAT21s REGISTER integral_literal ) 11762 { 11763 CommonTree root_1 = (CommonTree)adaptor.nil(); 11764 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21s, (retval.start), "I_STATEMENT_FORMAT21s"), root_1); 11765 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21s.nextNode()); 11766 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11767 adaptor.addChild(root_1, stream_integral_literal.nextTree()); 11768 adaptor.addChild(root_0, root_1); 11769 } 11770 11771 } 11772 11773 11774 retval.tree = root_0; 11775 11776 } 11777 11778 retval.stop = input.LT(-1); 11779 11780 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11781 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11782 11783 } 11784 catch (RecognitionException re) { 11785 reportError(re); 11786 recover(input,re); 11787 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11788 } 11789 finally { 11790 // do for sure before leaving 11791 } 11792 return retval; 11793 } 11794 // $ANTLR end "insn_format21s" 11795 11796 11797 public static class insn_format21t_return extends ParserRuleReturnScope { 11798 CommonTree tree; 11799 @Override getTree()11800 public CommonTree getTree() { return tree; } 11801 }; 11802 11803 11804 // $ANTLR start "insn_format21t" 11805 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:956:1: insn_format21t : INSTRUCTION_FORMAT21t REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT21t[$start, \"I_STATEMENT_FORMAT21t\"] INSTRUCTION_FORMAT21t REGISTER label_ref ) ; insn_format21t()11806 public final smaliParser.insn_format21t_return insn_format21t() throws RecognitionException { 11807 smaliParser.insn_format21t_return retval = new smaliParser.insn_format21t_return(); 11808 retval.start = input.LT(1); 11809 11810 CommonTree root_0 = null; 11811 11812 Token INSTRUCTION_FORMAT21t349=null; 11813 Token REGISTER350=null; 11814 Token COMMA351=null; 11815 ParserRuleReturnScope label_ref352 =null; 11816 11817 CommonTree INSTRUCTION_FORMAT21t349_tree=null; 11818 CommonTree REGISTER350_tree=null; 11819 CommonTree COMMA351_tree=null; 11820 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21t"); 11821 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11822 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11823 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 11824 11825 try { 11826 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:957:3: ( INSTRUCTION_FORMAT21t REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT21t[$start, \"I_STATEMENT_FORMAT21t\"] INSTRUCTION_FORMAT21t REGISTER label_ref ) ) 11827 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:958:5: INSTRUCTION_FORMAT21t REGISTER COMMA label_ref 11828 { 11829 INSTRUCTION_FORMAT21t349=(Token)match(input,INSTRUCTION_FORMAT21t,FOLLOW_INSTRUCTION_FORMAT21t_in_insn_format21t4718); 11830 stream_INSTRUCTION_FORMAT21t.add(INSTRUCTION_FORMAT21t349); 11831 11832 REGISTER350=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21t4720); 11833 stream_REGISTER.add(REGISTER350); 11834 11835 COMMA351=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21t4722); 11836 stream_COMMA.add(COMMA351); 11837 11838 pushFollow(FOLLOW_label_ref_in_insn_format21t4724); 11839 label_ref352=label_ref(); 11840 state._fsp--; 11841 11842 stream_label_ref.add(label_ref352.getTree()); 11843 // AST REWRITE 11844 // elements: label_ref, INSTRUCTION_FORMAT21t, REGISTER 11845 // token labels: 11846 // rule labels: retval 11847 // token list labels: 11848 // rule list labels: 11849 // wildcard labels: 11850 retval.tree = root_0; 11851 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11852 11853 root_0 = (CommonTree)adaptor.nil(); 11854 // 959:5: -> ^( I_STATEMENT_FORMAT21t[$start, \"I_STATEMENT_FORMAT21t\"] INSTRUCTION_FORMAT21t REGISTER label_ref ) 11855 { 11856 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:959:8: ^( I_STATEMENT_FORMAT21t[$start, \"I_STATEMENT_FORMAT21t\"] INSTRUCTION_FORMAT21t REGISTER label_ref ) 11857 { 11858 CommonTree root_1 = (CommonTree)adaptor.nil(); 11859 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21t, (retval.start), "I_STATEMENT_FORMAT21t"), root_1); 11860 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21t.nextNode()); 11861 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11862 adaptor.addChild(root_1, stream_label_ref.nextTree()); 11863 adaptor.addChild(root_0, root_1); 11864 } 11865 11866 } 11867 11868 11869 retval.tree = root_0; 11870 11871 } 11872 11873 retval.stop = input.LT(-1); 11874 11875 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11876 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11877 11878 } 11879 catch (RecognitionException re) { 11880 reportError(re); 11881 recover(input,re); 11882 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11883 } 11884 finally { 11885 // do for sure before leaving 11886 } 11887 return retval; 11888 } 11889 // $ANTLR end "insn_format21t" 11890 11891 11892 public static class insn_format22b_return extends ParserRuleReturnScope { 11893 CommonTree tree; 11894 @Override getTree()11895 public CommonTree getTree() { return tree; } 11896 }; 11897 11898 11899 // $ANTLR start "insn_format22b" 11900 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:961:1: insn_format22b : INSTRUCTION_FORMAT22b REGISTER COMMA REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT22b[$start, \"I_STATEMENT_FORMAT22b\"] INSTRUCTION_FORMAT22b REGISTER REGISTER integral_literal ) ; insn_format22b()11901 public final smaliParser.insn_format22b_return insn_format22b() throws RecognitionException { 11902 smaliParser.insn_format22b_return retval = new smaliParser.insn_format22b_return(); 11903 retval.start = input.LT(1); 11904 11905 CommonTree root_0 = null; 11906 11907 Token INSTRUCTION_FORMAT22b353=null; 11908 Token REGISTER354=null; 11909 Token COMMA355=null; 11910 Token REGISTER356=null; 11911 Token COMMA357=null; 11912 ParserRuleReturnScope integral_literal358 =null; 11913 11914 CommonTree INSTRUCTION_FORMAT22b353_tree=null; 11915 CommonTree REGISTER354_tree=null; 11916 CommonTree COMMA355_tree=null; 11917 CommonTree REGISTER356_tree=null; 11918 CommonTree COMMA357_tree=null; 11919 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11920 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11921 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22b=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22b"); 11922 RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal"); 11923 11924 try { 11925 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:962:3: ( INSTRUCTION_FORMAT22b REGISTER COMMA REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT22b[$start, \"I_STATEMENT_FORMAT22b\"] INSTRUCTION_FORMAT22b REGISTER REGISTER integral_literal ) ) 11926 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:963:5: INSTRUCTION_FORMAT22b REGISTER COMMA REGISTER COMMA integral_literal 11927 { 11928 INSTRUCTION_FORMAT22b353=(Token)match(input,INSTRUCTION_FORMAT22b,FOLLOW_INSTRUCTION_FORMAT22b_in_insn_format22b4756); 11929 stream_INSTRUCTION_FORMAT22b.add(INSTRUCTION_FORMAT22b353); 11930 11931 REGISTER354=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22b4758); 11932 stream_REGISTER.add(REGISTER354); 11933 11934 COMMA355=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22b4760); 11935 stream_COMMA.add(COMMA355); 11936 11937 REGISTER356=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22b4762); 11938 stream_REGISTER.add(REGISTER356); 11939 11940 COMMA357=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22b4764); 11941 stream_COMMA.add(COMMA357); 11942 11943 pushFollow(FOLLOW_integral_literal_in_insn_format22b4766); 11944 integral_literal358=integral_literal(); 11945 state._fsp--; 11946 11947 stream_integral_literal.add(integral_literal358.getTree()); 11948 // AST REWRITE 11949 // elements: REGISTER, INSTRUCTION_FORMAT22b, REGISTER, integral_literal 11950 // token labels: 11951 // rule labels: retval 11952 // token list labels: 11953 // rule list labels: 11954 // wildcard labels: 11955 retval.tree = root_0; 11956 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11957 11958 root_0 = (CommonTree)adaptor.nil(); 11959 // 964:5: -> ^( I_STATEMENT_FORMAT22b[$start, \"I_STATEMENT_FORMAT22b\"] INSTRUCTION_FORMAT22b REGISTER REGISTER integral_literal ) 11960 { 11961 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:964:8: ^( I_STATEMENT_FORMAT22b[$start, \"I_STATEMENT_FORMAT22b\"] INSTRUCTION_FORMAT22b REGISTER REGISTER integral_literal ) 11962 { 11963 CommonTree root_1 = (CommonTree)adaptor.nil(); 11964 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22b, (retval.start), "I_STATEMENT_FORMAT22b"), root_1); 11965 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22b.nextNode()); 11966 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11967 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11968 adaptor.addChild(root_1, stream_integral_literal.nextTree()); 11969 adaptor.addChild(root_0, root_1); 11970 } 11971 11972 } 11973 11974 11975 retval.tree = root_0; 11976 11977 } 11978 11979 retval.stop = input.LT(-1); 11980 11981 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11982 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11983 11984 } 11985 catch (RecognitionException re) { 11986 reportError(re); 11987 recover(input,re); 11988 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11989 } 11990 finally { 11991 // do for sure before leaving 11992 } 11993 return retval; 11994 } 11995 // $ANTLR end "insn_format22b" 11996 11997 11998 public static class insn_format22c_field_return extends ParserRuleReturnScope { 11999 CommonTree tree; 12000 @Override getTree()12001 public CommonTree getTree() { return tree; } 12002 }; 12003 12004 12005 // $ANTLR start "insn_format22c_field" 12006 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:966: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 ) ; insn_format22c_field()12007 public final smaliParser.insn_format22c_field_return insn_format22c_field() throws RecognitionException { 12008 smaliParser.insn_format22c_field_return retval = new smaliParser.insn_format22c_field_return(); 12009 retval.start = input.LT(1); 12010 12011 CommonTree root_0 = null; 12012 12013 Token INSTRUCTION_FORMAT22c_FIELD359=null; 12014 Token REGISTER360=null; 12015 Token COMMA361=null; 12016 Token REGISTER362=null; 12017 Token COMMA363=null; 12018 ParserRuleReturnScope field_reference364 =null; 12019 12020 CommonTree INSTRUCTION_FORMAT22c_FIELD359_tree=null; 12021 CommonTree REGISTER360_tree=null; 12022 CommonTree COMMA361_tree=null; 12023 CommonTree REGISTER362_tree=null; 12024 CommonTree COMMA363_tree=null; 12025 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12026 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12027 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_FIELD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_FIELD"); 12028 RewriteRuleSubtreeStream stream_field_reference=new RewriteRuleSubtreeStream(adaptor,"rule field_reference"); 12029 12030 try { 12031 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:967: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 ) ) 12032 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:968:5: INSTRUCTION_FORMAT22c_FIELD REGISTER COMMA REGISTER COMMA field_reference 12033 { 12034 INSTRUCTION_FORMAT22c_FIELD359=(Token)match(input,INSTRUCTION_FORMAT22c_FIELD,FOLLOW_INSTRUCTION_FORMAT22c_FIELD_in_insn_format22c_field4800); 12035 stream_INSTRUCTION_FORMAT22c_FIELD.add(INSTRUCTION_FORMAT22c_FIELD359); 12036 12037 REGISTER360=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_field4802); 12038 stream_REGISTER.add(REGISTER360); 12039 12040 COMMA361=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_field4804); 12041 stream_COMMA.add(COMMA361); 12042 12043 REGISTER362=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_field4806); 12044 stream_REGISTER.add(REGISTER362); 12045 12046 COMMA363=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_field4808); 12047 stream_COMMA.add(COMMA363); 12048 12049 pushFollow(FOLLOW_field_reference_in_insn_format22c_field4810); 12050 field_reference364=field_reference(); 12051 state._fsp--; 12052 12053 stream_field_reference.add(field_reference364.getTree()); 12054 // AST REWRITE 12055 // elements: REGISTER, REGISTER, INSTRUCTION_FORMAT22c_FIELD, field_reference 12056 // token labels: 12057 // rule labels: retval 12058 // token list labels: 12059 // rule list labels: 12060 // wildcard labels: 12061 retval.tree = root_0; 12062 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12063 12064 root_0 = (CommonTree)adaptor.nil(); 12065 // 969:5: -> ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD REGISTER REGISTER field_reference ) 12066 { 12067 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:969:8: ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD REGISTER REGISTER field_reference ) 12068 { 12069 CommonTree root_1 = (CommonTree)adaptor.nil(); 12070 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22c_FIELD, (retval.start), "I_STATEMENT_FORMAT22c_FIELD"), root_1); 12071 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22c_FIELD.nextNode()); 12072 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12073 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12074 adaptor.addChild(root_1, stream_field_reference.nextTree()); 12075 adaptor.addChild(root_0, root_1); 12076 } 12077 12078 } 12079 12080 12081 retval.tree = root_0; 12082 12083 } 12084 12085 retval.stop = input.LT(-1); 12086 12087 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12088 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12089 12090 } 12091 catch (RecognitionException re) { 12092 reportError(re); 12093 recover(input,re); 12094 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12095 } 12096 finally { 12097 // do for sure before leaving 12098 } 12099 return retval; 12100 } 12101 // $ANTLR end "insn_format22c_field" 12102 12103 12104 public static class insn_format22c_field_odex_return extends ParserRuleReturnScope { 12105 CommonTree tree; 12106 @Override getTree()12107 public CommonTree getTree() { return tree; } 12108 }; 12109 12110 12111 // $ANTLR start "insn_format22c_field_odex" 12112 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:971: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 ) ; insn_format22c_field_odex()12113 public final smaliParser.insn_format22c_field_odex_return insn_format22c_field_odex() throws RecognitionException { 12114 smaliParser.insn_format22c_field_odex_return retval = new smaliParser.insn_format22c_field_odex_return(); 12115 retval.start = input.LT(1); 12116 12117 CommonTree root_0 = null; 12118 12119 Token INSTRUCTION_FORMAT22c_FIELD_ODEX365=null; 12120 Token REGISTER366=null; 12121 Token COMMA367=null; 12122 Token REGISTER368=null; 12123 Token COMMA369=null; 12124 ParserRuleReturnScope field_reference370 =null; 12125 12126 CommonTree INSTRUCTION_FORMAT22c_FIELD_ODEX365_tree=null; 12127 CommonTree REGISTER366_tree=null; 12128 CommonTree COMMA367_tree=null; 12129 CommonTree REGISTER368_tree=null; 12130 CommonTree COMMA369_tree=null; 12131 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_FIELD_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_FIELD_ODEX"); 12132 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12133 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12134 RewriteRuleSubtreeStream stream_field_reference=new RewriteRuleSubtreeStream(adaptor,"rule field_reference"); 12135 12136 try { 12137 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:972: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 ) ) 12138 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:973:5: INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER COMMA REGISTER COMMA field_reference 12139 { 12140 INSTRUCTION_FORMAT22c_FIELD_ODEX365=(Token)match(input,INSTRUCTION_FORMAT22c_FIELD_ODEX,FOLLOW_INSTRUCTION_FORMAT22c_FIELD_ODEX_in_insn_format22c_field_odex4844); 12141 stream_INSTRUCTION_FORMAT22c_FIELD_ODEX.add(INSTRUCTION_FORMAT22c_FIELD_ODEX365); 12142 12143 REGISTER366=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_field_odex4846); 12144 stream_REGISTER.add(REGISTER366); 12145 12146 COMMA367=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_field_odex4848); 12147 stream_COMMA.add(COMMA367); 12148 12149 REGISTER368=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_field_odex4850); 12150 stream_REGISTER.add(REGISTER368); 12151 12152 COMMA369=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_field_odex4852); 12153 stream_COMMA.add(COMMA369); 12154 12155 pushFollow(FOLLOW_field_reference_in_insn_format22c_field_odex4854); 12156 field_reference370=field_reference(); 12157 state._fsp--; 12158 12159 stream_field_reference.add(field_reference370.getTree()); 12160 12161 if (!allowOdex || opcodes.getOpcodeByName((INSTRUCTION_FORMAT22c_FIELD_ODEX365!=null?INSTRUCTION_FORMAT22c_FIELD_ODEX365.getText():null)) == null || apiLevel >= 14) { 12162 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT22c_FIELD_ODEX365!=null?INSTRUCTION_FORMAT22c_FIELD_ODEX365.getText():null)); 12163 } 12164 12165 // AST REWRITE 12166 // elements: INSTRUCTION_FORMAT22c_FIELD_ODEX, REGISTER, field_reference, REGISTER 12167 // token labels: 12168 // rule labels: retval 12169 // token list labels: 12170 // rule list labels: 12171 // wildcard labels: 12172 retval.tree = root_0; 12173 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12174 12175 root_0 = (CommonTree)adaptor.nil(); 12176 // 979:5: -> ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER REGISTER field_reference ) 12177 { 12178 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:979:8: ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER REGISTER field_reference ) 12179 { 12180 CommonTree root_1 = (CommonTree)adaptor.nil(); 12181 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22c_FIELD, (retval.start), "I_STATEMENT_FORMAT22c_FIELD"), root_1); 12182 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22c_FIELD_ODEX.nextNode()); 12183 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12184 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12185 adaptor.addChild(root_1, stream_field_reference.nextTree()); 12186 adaptor.addChild(root_0, root_1); 12187 } 12188 12189 } 12190 12191 12192 retval.tree = root_0; 12193 12194 } 12195 12196 retval.stop = input.LT(-1); 12197 12198 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12199 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12200 12201 } 12202 catch (RecognitionException re) { 12203 reportError(re); 12204 recover(input,re); 12205 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12206 } 12207 finally { 12208 // do for sure before leaving 12209 } 12210 return retval; 12211 } 12212 // $ANTLR end "insn_format22c_field_odex" 12213 12214 12215 public static class insn_format22c_type_return extends ParserRuleReturnScope { 12216 CommonTree tree; 12217 @Override getTree()12218 public CommonTree getTree() { return tree; } 12219 }; 12220 12221 12222 // $ANTLR start "insn_format22c_type" 12223 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:981: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 ) ; insn_format22c_type()12224 public final smaliParser.insn_format22c_type_return insn_format22c_type() throws RecognitionException { 12225 smaliParser.insn_format22c_type_return retval = new smaliParser.insn_format22c_type_return(); 12226 retval.start = input.LT(1); 12227 12228 CommonTree root_0 = null; 12229 12230 Token INSTRUCTION_FORMAT22c_TYPE371=null; 12231 Token REGISTER372=null; 12232 Token COMMA373=null; 12233 Token REGISTER374=null; 12234 Token COMMA375=null; 12235 ParserRuleReturnScope nonvoid_type_descriptor376 =null; 12236 12237 CommonTree INSTRUCTION_FORMAT22c_TYPE371_tree=null; 12238 CommonTree REGISTER372_tree=null; 12239 CommonTree COMMA373_tree=null; 12240 CommonTree REGISTER374_tree=null; 12241 CommonTree COMMA375_tree=null; 12242 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_TYPE"); 12243 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12244 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12245 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 12246 12247 try { 12248 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:982: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 ) ) 12249 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:983:5: INSTRUCTION_FORMAT22c_TYPE REGISTER COMMA REGISTER COMMA nonvoid_type_descriptor 12250 { 12251 INSTRUCTION_FORMAT22c_TYPE371=(Token)match(input,INSTRUCTION_FORMAT22c_TYPE,FOLLOW_INSTRUCTION_FORMAT22c_TYPE_in_insn_format22c_type4894); 12252 stream_INSTRUCTION_FORMAT22c_TYPE.add(INSTRUCTION_FORMAT22c_TYPE371); 12253 12254 REGISTER372=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_type4896); 12255 stream_REGISTER.add(REGISTER372); 12256 12257 COMMA373=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_type4898); 12258 stream_COMMA.add(COMMA373); 12259 12260 REGISTER374=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_type4900); 12261 stream_REGISTER.add(REGISTER374); 12262 12263 COMMA375=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_type4902); 12264 stream_COMMA.add(COMMA375); 12265 12266 pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format22c_type4904); 12267 nonvoid_type_descriptor376=nonvoid_type_descriptor(); 12268 state._fsp--; 12269 12270 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor376.getTree()); 12271 // AST REWRITE 12272 // elements: REGISTER, nonvoid_type_descriptor, REGISTER, INSTRUCTION_FORMAT22c_TYPE 12273 // token labels: 12274 // rule labels: retval 12275 // token list labels: 12276 // rule list labels: 12277 // wildcard labels: 12278 retval.tree = root_0; 12279 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12280 12281 root_0 = (CommonTree)adaptor.nil(); 12282 // 984:5: -> ^( I_STATEMENT_FORMAT22c_TYPE[$start, \"I_STATEMENT_FORMAT22c_TYPE\"] INSTRUCTION_FORMAT22c_TYPE REGISTER REGISTER nonvoid_type_descriptor ) 12283 { 12284 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:984:8: ^( I_STATEMENT_FORMAT22c_TYPE[$start, \"I_STATEMENT_FORMAT22c_TYPE\"] INSTRUCTION_FORMAT22c_TYPE REGISTER REGISTER nonvoid_type_descriptor ) 12285 { 12286 CommonTree root_1 = (CommonTree)adaptor.nil(); 12287 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22c_TYPE, (retval.start), "I_STATEMENT_FORMAT22c_TYPE"), root_1); 12288 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22c_TYPE.nextNode()); 12289 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12290 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12291 adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree()); 12292 adaptor.addChild(root_0, root_1); 12293 } 12294 12295 } 12296 12297 12298 retval.tree = root_0; 12299 12300 } 12301 12302 retval.stop = input.LT(-1); 12303 12304 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12305 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12306 12307 } 12308 catch (RecognitionException re) { 12309 reportError(re); 12310 recover(input,re); 12311 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12312 } 12313 finally { 12314 // do for sure before leaving 12315 } 12316 return retval; 12317 } 12318 // $ANTLR end "insn_format22c_type" 12319 12320 12321 public static class insn_format22c_string_return extends ParserRuleReturnScope { 12322 CommonTree tree; 12323 @Override getTree()12324 public CommonTree getTree() { return tree; } 12325 }; 12326 12327 12328 // $ANTLR start "insn_format22c_string" 12329 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:986:1: insn_format22c_string : INSTRUCTION_FORMAT22c_STRING REGISTER COMMA REGISTER COMMA STRING_LITERAL -> ^( I_STATEMENT_FORMAT22c_STRING[$start, \"I_STATEMENT_FORMAT22c_STRING\"] INSTRUCTION_FORMAT22c_STRING REGISTER REGISTER STRING_LITERAL ) ; insn_format22c_string()12330 public final smaliParser.insn_format22c_string_return insn_format22c_string() throws RecognitionException { 12331 smaliParser.insn_format22c_string_return retval = new smaliParser.insn_format22c_string_return(); 12332 retval.start = input.LT(1); 12333 12334 CommonTree root_0 = null; 12335 12336 Token INSTRUCTION_FORMAT22c_STRING377=null; 12337 Token REGISTER378=null; 12338 Token COMMA379=null; 12339 Token REGISTER380=null; 12340 Token COMMA381=null; 12341 Token STRING_LITERAL382=null; 12342 12343 CommonTree INSTRUCTION_FORMAT22c_STRING377_tree=null; 12344 CommonTree REGISTER378_tree=null; 12345 CommonTree COMMA379_tree=null; 12346 CommonTree REGISTER380_tree=null; 12347 CommonTree COMMA381_tree=null; 12348 CommonTree STRING_LITERAL382_tree=null; 12349 RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL"); 12350 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_STRING=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_STRING"); 12351 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12352 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12353 12354 try { 12355 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:987:3: ( INSTRUCTION_FORMAT22c_STRING REGISTER COMMA REGISTER COMMA STRING_LITERAL -> ^( I_STATEMENT_FORMAT22c_STRING[$start, \"I_STATEMENT_FORMAT22c_STRING\"] INSTRUCTION_FORMAT22c_STRING REGISTER REGISTER STRING_LITERAL ) ) 12356 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:988:5: INSTRUCTION_FORMAT22c_STRING REGISTER COMMA REGISTER COMMA STRING_LITERAL 12357 { 12358 INSTRUCTION_FORMAT22c_STRING377=(Token)match(input,INSTRUCTION_FORMAT22c_STRING,FOLLOW_INSTRUCTION_FORMAT22c_STRING_in_insn_format22c_string4938); 12359 stream_INSTRUCTION_FORMAT22c_STRING.add(INSTRUCTION_FORMAT22c_STRING377); 12360 12361 REGISTER378=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_string4940); 12362 stream_REGISTER.add(REGISTER378); 12363 12364 COMMA379=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_string4942); 12365 stream_COMMA.add(COMMA379); 12366 12367 REGISTER380=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_string4944); 12368 stream_REGISTER.add(REGISTER380); 12369 12370 COMMA381=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_string4946); 12371 stream_COMMA.add(COMMA381); 12372 12373 STRING_LITERAL382=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_insn_format22c_string4948); 12374 stream_STRING_LITERAL.add(STRING_LITERAL382); 12375 12376 // AST REWRITE 12377 // elements: STRING_LITERAL, REGISTER, REGISTER, INSTRUCTION_FORMAT22c_STRING 12378 // token labels: 12379 // rule labels: retval 12380 // token list labels: 12381 // rule list labels: 12382 // wildcard labels: 12383 retval.tree = root_0; 12384 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12385 12386 root_0 = (CommonTree)adaptor.nil(); 12387 // 989:5: -> ^( I_STATEMENT_FORMAT22c_STRING[$start, \"I_STATEMENT_FORMAT22c_STRING\"] INSTRUCTION_FORMAT22c_STRING REGISTER REGISTER STRING_LITERAL ) 12388 { 12389 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:989:8: ^( I_STATEMENT_FORMAT22c_STRING[$start, \"I_STATEMENT_FORMAT22c_STRING\"] INSTRUCTION_FORMAT22c_STRING REGISTER REGISTER STRING_LITERAL ) 12390 { 12391 CommonTree root_1 = (CommonTree)adaptor.nil(); 12392 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22c_STRING, (retval.start), "I_STATEMENT_FORMAT22c_STRING"), root_1); 12393 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22c_STRING.nextNode()); 12394 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12395 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12396 adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode()); 12397 adaptor.addChild(root_0, root_1); 12398 } 12399 12400 } 12401 12402 12403 retval.tree = root_0; 12404 12405 } 12406 12407 retval.stop = input.LT(-1); 12408 12409 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12410 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12411 12412 } 12413 catch (RecognitionException re) { 12414 reportError(re); 12415 recover(input,re); 12416 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12417 } 12418 finally { 12419 // do for sure before leaving 12420 } 12421 return retval; 12422 } 12423 // $ANTLR end "insn_format22c_string" 12424 12425 12426 public static class insn_format22cs_field_return extends ParserRuleReturnScope { 12427 CommonTree tree; 12428 @Override getTree()12429 public CommonTree getTree() { return tree; } 12430 }; 12431 12432 12433 // $ANTLR start "insn_format22cs_field" 12434 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:991:1: insn_format22cs_field : INSTRUCTION_FORMAT22cs_FIELD REGISTER COMMA REGISTER COMMA FIELD_OFFSET ; insn_format22cs_field()12435 public final smaliParser.insn_format22cs_field_return insn_format22cs_field() throws RecognitionException { 12436 smaliParser.insn_format22cs_field_return retval = new smaliParser.insn_format22cs_field_return(); 12437 retval.start = input.LT(1); 12438 12439 CommonTree root_0 = null; 12440 12441 Token INSTRUCTION_FORMAT22cs_FIELD383=null; 12442 Token REGISTER384=null; 12443 Token COMMA385=null; 12444 Token REGISTER386=null; 12445 Token COMMA387=null; 12446 Token FIELD_OFFSET388=null; 12447 12448 CommonTree INSTRUCTION_FORMAT22cs_FIELD383_tree=null; 12449 CommonTree REGISTER384_tree=null; 12450 CommonTree COMMA385_tree=null; 12451 CommonTree REGISTER386_tree=null; 12452 CommonTree COMMA387_tree=null; 12453 CommonTree FIELD_OFFSET388_tree=null; 12454 12455 try { 12456 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:992:3: ( INSTRUCTION_FORMAT22cs_FIELD REGISTER COMMA REGISTER COMMA FIELD_OFFSET ) 12457 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:993:5: INSTRUCTION_FORMAT22cs_FIELD REGISTER COMMA REGISTER COMMA FIELD_OFFSET 12458 { 12459 root_0 = (CommonTree)adaptor.nil(); 12460 12461 12462 INSTRUCTION_FORMAT22cs_FIELD383=(Token)match(input,INSTRUCTION_FORMAT22cs_FIELD,FOLLOW_INSTRUCTION_FORMAT22cs_FIELD_in_insn_format22cs_field4982); 12463 INSTRUCTION_FORMAT22cs_FIELD383_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT22cs_FIELD383); 12464 adaptor.addChild(root_0, INSTRUCTION_FORMAT22cs_FIELD383_tree); 12465 12466 REGISTER384=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22cs_field4984); 12467 REGISTER384_tree = (CommonTree)adaptor.create(REGISTER384); 12468 adaptor.addChild(root_0, REGISTER384_tree); 12469 12470 COMMA385=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22cs_field4986); 12471 COMMA385_tree = (CommonTree)adaptor.create(COMMA385); 12472 adaptor.addChild(root_0, COMMA385_tree); 12473 12474 REGISTER386=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22cs_field4988); 12475 REGISTER386_tree = (CommonTree)adaptor.create(REGISTER386); 12476 adaptor.addChild(root_0, REGISTER386_tree); 12477 12478 COMMA387=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22cs_field4990); 12479 COMMA387_tree = (CommonTree)adaptor.create(COMMA387); 12480 adaptor.addChild(root_0, COMMA387_tree); 12481 12482 FIELD_OFFSET388=(Token)match(input,FIELD_OFFSET,FOLLOW_FIELD_OFFSET_in_insn_format22cs_field4992); 12483 FIELD_OFFSET388_tree = (CommonTree)adaptor.create(FIELD_OFFSET388); 12484 adaptor.addChild(root_0, FIELD_OFFSET388_tree); 12485 12486 12487 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT22cs_FIELD383!=null?INSTRUCTION_FORMAT22cs_FIELD383.getText():null)); 12488 12489 } 12490 12491 retval.stop = input.LT(-1); 12492 12493 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12494 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12495 12496 } 12497 catch (RecognitionException re) { 12498 reportError(re); 12499 recover(input,re); 12500 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12501 } 12502 finally { 12503 // do for sure before leaving 12504 } 12505 return retval; 12506 } 12507 // $ANTLR end "insn_format22cs_field" 12508 12509 12510 public static class insn_format22s_return extends ParserRuleReturnScope { 12511 CommonTree tree; 12512 @Override getTree()12513 public CommonTree getTree() { return tree; } 12514 }; 12515 12516 12517 // $ANTLR start "insn_format22s" 12518 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:998:1: insn_format22s : instruction_format22s REGISTER COMMA REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT22s[$start, \"I_STATEMENT_FORMAT22s\"] instruction_format22s REGISTER REGISTER integral_literal ) ; insn_format22s()12519 public final smaliParser.insn_format22s_return insn_format22s() throws RecognitionException { 12520 smaliParser.insn_format22s_return retval = new smaliParser.insn_format22s_return(); 12521 retval.start = input.LT(1); 12522 12523 CommonTree root_0 = null; 12524 12525 Token REGISTER390=null; 12526 Token COMMA391=null; 12527 Token REGISTER392=null; 12528 Token COMMA393=null; 12529 ParserRuleReturnScope instruction_format22s389 =null; 12530 ParserRuleReturnScope integral_literal394 =null; 12531 12532 CommonTree REGISTER390_tree=null; 12533 CommonTree COMMA391_tree=null; 12534 CommonTree REGISTER392_tree=null; 12535 CommonTree COMMA393_tree=null; 12536 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12537 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12538 RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal"); 12539 RewriteRuleSubtreeStream stream_instruction_format22s=new RewriteRuleSubtreeStream(adaptor,"rule instruction_format22s"); 12540 12541 try { 12542 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:999:3: ( instruction_format22s REGISTER COMMA REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT22s[$start, \"I_STATEMENT_FORMAT22s\"] instruction_format22s REGISTER REGISTER integral_literal ) ) 12543 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1000:5: instruction_format22s REGISTER COMMA REGISTER COMMA integral_literal 12544 { 12545 pushFollow(FOLLOW_instruction_format22s_in_insn_format22s5013); 12546 instruction_format22s389=instruction_format22s(); 12547 state._fsp--; 12548 12549 stream_instruction_format22s.add(instruction_format22s389.getTree()); 12550 REGISTER390=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22s5015); 12551 stream_REGISTER.add(REGISTER390); 12552 12553 COMMA391=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22s5017); 12554 stream_COMMA.add(COMMA391); 12555 12556 REGISTER392=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22s5019); 12557 stream_REGISTER.add(REGISTER392); 12558 12559 COMMA393=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22s5021); 12560 stream_COMMA.add(COMMA393); 12561 12562 pushFollow(FOLLOW_integral_literal_in_insn_format22s5023); 12563 integral_literal394=integral_literal(); 12564 state._fsp--; 12565 12566 stream_integral_literal.add(integral_literal394.getTree()); 12567 // AST REWRITE 12568 // elements: REGISTER, instruction_format22s, REGISTER, integral_literal 12569 // token labels: 12570 // rule labels: retval 12571 // token list labels: 12572 // rule list labels: 12573 // wildcard labels: 12574 retval.tree = root_0; 12575 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12576 12577 root_0 = (CommonTree)adaptor.nil(); 12578 // 1001:5: -> ^( I_STATEMENT_FORMAT22s[$start, \"I_STATEMENT_FORMAT22s\"] instruction_format22s REGISTER REGISTER integral_literal ) 12579 { 12580 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1001:8: ^( I_STATEMENT_FORMAT22s[$start, \"I_STATEMENT_FORMAT22s\"] instruction_format22s REGISTER REGISTER integral_literal ) 12581 { 12582 CommonTree root_1 = (CommonTree)adaptor.nil(); 12583 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22s, (retval.start), "I_STATEMENT_FORMAT22s"), root_1); 12584 adaptor.addChild(root_1, stream_instruction_format22s.nextTree()); 12585 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12586 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12587 adaptor.addChild(root_1, stream_integral_literal.nextTree()); 12588 adaptor.addChild(root_0, root_1); 12589 } 12590 12591 } 12592 12593 12594 retval.tree = root_0; 12595 12596 } 12597 12598 retval.stop = input.LT(-1); 12599 12600 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12601 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12602 12603 } 12604 catch (RecognitionException re) { 12605 reportError(re); 12606 recover(input,re); 12607 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12608 } 12609 finally { 12610 // do for sure before leaving 12611 } 12612 return retval; 12613 } 12614 // $ANTLR end "insn_format22s" 12615 12616 12617 public static class insn_format22t_return extends ParserRuleReturnScope { 12618 CommonTree tree; 12619 @Override getTree()12620 public CommonTree getTree() { return tree; } 12621 }; 12622 12623 12624 // $ANTLR start "insn_format22t" 12625 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1003:1: insn_format22t : INSTRUCTION_FORMAT22t REGISTER COMMA REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT22t[$start, \"I_STATEMENT_FFORMAT22t\"] INSTRUCTION_FORMAT22t REGISTER REGISTER label_ref ) ; insn_format22t()12626 public final smaliParser.insn_format22t_return insn_format22t() throws RecognitionException { 12627 smaliParser.insn_format22t_return retval = new smaliParser.insn_format22t_return(); 12628 retval.start = input.LT(1); 12629 12630 CommonTree root_0 = null; 12631 12632 Token INSTRUCTION_FORMAT22t395=null; 12633 Token REGISTER396=null; 12634 Token COMMA397=null; 12635 Token REGISTER398=null; 12636 Token COMMA399=null; 12637 ParserRuleReturnScope label_ref400 =null; 12638 12639 CommonTree INSTRUCTION_FORMAT22t395_tree=null; 12640 CommonTree REGISTER396_tree=null; 12641 CommonTree COMMA397_tree=null; 12642 CommonTree REGISTER398_tree=null; 12643 CommonTree COMMA399_tree=null; 12644 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12645 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12646 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22t"); 12647 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 12648 12649 try { 12650 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1004:3: ( INSTRUCTION_FORMAT22t REGISTER COMMA REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT22t[$start, \"I_STATEMENT_FFORMAT22t\"] INSTRUCTION_FORMAT22t REGISTER REGISTER label_ref ) ) 12651 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1005:5: INSTRUCTION_FORMAT22t REGISTER COMMA REGISTER COMMA label_ref 12652 { 12653 INSTRUCTION_FORMAT22t395=(Token)match(input,INSTRUCTION_FORMAT22t,FOLLOW_INSTRUCTION_FORMAT22t_in_insn_format22t5057); 12654 stream_INSTRUCTION_FORMAT22t.add(INSTRUCTION_FORMAT22t395); 12655 12656 REGISTER396=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22t5059); 12657 stream_REGISTER.add(REGISTER396); 12658 12659 COMMA397=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22t5061); 12660 stream_COMMA.add(COMMA397); 12661 12662 REGISTER398=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22t5063); 12663 stream_REGISTER.add(REGISTER398); 12664 12665 COMMA399=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22t5065); 12666 stream_COMMA.add(COMMA399); 12667 12668 pushFollow(FOLLOW_label_ref_in_insn_format22t5067); 12669 label_ref400=label_ref(); 12670 state._fsp--; 12671 12672 stream_label_ref.add(label_ref400.getTree()); 12673 // AST REWRITE 12674 // elements: label_ref, REGISTER, REGISTER, INSTRUCTION_FORMAT22t 12675 // token labels: 12676 // rule labels: retval 12677 // token list labels: 12678 // rule list labels: 12679 // wildcard labels: 12680 retval.tree = root_0; 12681 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12682 12683 root_0 = (CommonTree)adaptor.nil(); 12684 // 1006:5: -> ^( I_STATEMENT_FORMAT22t[$start, \"I_STATEMENT_FFORMAT22t\"] INSTRUCTION_FORMAT22t REGISTER REGISTER label_ref ) 12685 { 12686 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1006:8: ^( I_STATEMENT_FORMAT22t[$start, \"I_STATEMENT_FFORMAT22t\"] INSTRUCTION_FORMAT22t REGISTER REGISTER label_ref ) 12687 { 12688 CommonTree root_1 = (CommonTree)adaptor.nil(); 12689 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22t, (retval.start), "I_STATEMENT_FFORMAT22t"), root_1); 12690 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22t.nextNode()); 12691 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12692 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12693 adaptor.addChild(root_1, stream_label_ref.nextTree()); 12694 adaptor.addChild(root_0, root_1); 12695 } 12696 12697 } 12698 12699 12700 retval.tree = root_0; 12701 12702 } 12703 12704 retval.stop = input.LT(-1); 12705 12706 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12707 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12708 12709 } 12710 catch (RecognitionException re) { 12711 reportError(re); 12712 recover(input,re); 12713 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12714 } 12715 finally { 12716 // do for sure before leaving 12717 } 12718 return retval; 12719 } 12720 // $ANTLR end "insn_format22t" 12721 12722 12723 public static class insn_format22x_return extends ParserRuleReturnScope { 12724 CommonTree tree; 12725 @Override getTree()12726 public CommonTree getTree() { return tree; } 12727 }; 12728 12729 12730 // $ANTLR start "insn_format22x" 12731 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1008:1: insn_format22x : INSTRUCTION_FORMAT22x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT22x[$start, \"I_STATEMENT_FORMAT22x\"] INSTRUCTION_FORMAT22x REGISTER REGISTER ) ; insn_format22x()12732 public final smaliParser.insn_format22x_return insn_format22x() throws RecognitionException { 12733 smaliParser.insn_format22x_return retval = new smaliParser.insn_format22x_return(); 12734 retval.start = input.LT(1); 12735 12736 CommonTree root_0 = null; 12737 12738 Token INSTRUCTION_FORMAT22x401=null; 12739 Token REGISTER402=null; 12740 Token COMMA403=null; 12741 Token REGISTER404=null; 12742 12743 CommonTree INSTRUCTION_FORMAT22x401_tree=null; 12744 CommonTree REGISTER402_tree=null; 12745 CommonTree COMMA403_tree=null; 12746 CommonTree REGISTER404_tree=null; 12747 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22x"); 12748 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12749 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12750 12751 try { 12752 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1009:3: ( INSTRUCTION_FORMAT22x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT22x[$start, \"I_STATEMENT_FORMAT22x\"] INSTRUCTION_FORMAT22x REGISTER REGISTER ) ) 12753 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1010:5: INSTRUCTION_FORMAT22x REGISTER COMMA REGISTER 12754 { 12755 INSTRUCTION_FORMAT22x401=(Token)match(input,INSTRUCTION_FORMAT22x,FOLLOW_INSTRUCTION_FORMAT22x_in_insn_format22x5101); 12756 stream_INSTRUCTION_FORMAT22x.add(INSTRUCTION_FORMAT22x401); 12757 12758 REGISTER402=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22x5103); 12759 stream_REGISTER.add(REGISTER402); 12760 12761 COMMA403=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22x5105); 12762 stream_COMMA.add(COMMA403); 12763 12764 REGISTER404=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22x5107); 12765 stream_REGISTER.add(REGISTER404); 12766 12767 // AST REWRITE 12768 // elements: INSTRUCTION_FORMAT22x, REGISTER, REGISTER 12769 // token labels: 12770 // rule labels: retval 12771 // token list labels: 12772 // rule list labels: 12773 // wildcard labels: 12774 retval.tree = root_0; 12775 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12776 12777 root_0 = (CommonTree)adaptor.nil(); 12778 // 1011:5: -> ^( I_STATEMENT_FORMAT22x[$start, \"I_STATEMENT_FORMAT22x\"] INSTRUCTION_FORMAT22x REGISTER REGISTER ) 12779 { 12780 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1011:8: ^( I_STATEMENT_FORMAT22x[$start, \"I_STATEMENT_FORMAT22x\"] INSTRUCTION_FORMAT22x REGISTER REGISTER ) 12781 { 12782 CommonTree root_1 = (CommonTree)adaptor.nil(); 12783 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22x, (retval.start), "I_STATEMENT_FORMAT22x"), root_1); 12784 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22x.nextNode()); 12785 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12786 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12787 adaptor.addChild(root_0, root_1); 12788 } 12789 12790 } 12791 12792 12793 retval.tree = root_0; 12794 12795 } 12796 12797 retval.stop = input.LT(-1); 12798 12799 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12800 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12801 12802 } 12803 catch (RecognitionException re) { 12804 reportError(re); 12805 recover(input,re); 12806 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12807 } 12808 finally { 12809 // do for sure before leaving 12810 } 12811 return retval; 12812 } 12813 // $ANTLR end "insn_format22x" 12814 12815 12816 public static class insn_format23x_return extends ParserRuleReturnScope { 12817 CommonTree tree; 12818 @Override getTree()12819 public CommonTree getTree() { return tree; } 12820 }; 12821 12822 12823 // $ANTLR start "insn_format23x" 12824 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1013:1: insn_format23x : INSTRUCTION_FORMAT23x REGISTER COMMA REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT23x[$start, \"I_STATEMENT_FORMAT23x\"] INSTRUCTION_FORMAT23x REGISTER REGISTER REGISTER ) ; insn_format23x()12825 public final smaliParser.insn_format23x_return insn_format23x() throws RecognitionException { 12826 smaliParser.insn_format23x_return retval = new smaliParser.insn_format23x_return(); 12827 retval.start = input.LT(1); 12828 12829 CommonTree root_0 = null; 12830 12831 Token INSTRUCTION_FORMAT23x405=null; 12832 Token REGISTER406=null; 12833 Token COMMA407=null; 12834 Token REGISTER408=null; 12835 Token COMMA409=null; 12836 Token REGISTER410=null; 12837 12838 CommonTree INSTRUCTION_FORMAT23x405_tree=null; 12839 CommonTree REGISTER406_tree=null; 12840 CommonTree COMMA407_tree=null; 12841 CommonTree REGISTER408_tree=null; 12842 CommonTree COMMA409_tree=null; 12843 CommonTree REGISTER410_tree=null; 12844 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12845 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12846 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT23x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT23x"); 12847 12848 try { 12849 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1014:3: ( INSTRUCTION_FORMAT23x REGISTER COMMA REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT23x[$start, \"I_STATEMENT_FORMAT23x\"] INSTRUCTION_FORMAT23x REGISTER REGISTER REGISTER ) ) 12850 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1015:5: INSTRUCTION_FORMAT23x REGISTER COMMA REGISTER COMMA REGISTER 12851 { 12852 INSTRUCTION_FORMAT23x405=(Token)match(input,INSTRUCTION_FORMAT23x,FOLLOW_INSTRUCTION_FORMAT23x_in_insn_format23x5139); 12853 stream_INSTRUCTION_FORMAT23x.add(INSTRUCTION_FORMAT23x405); 12854 12855 REGISTER406=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format23x5141); 12856 stream_REGISTER.add(REGISTER406); 12857 12858 COMMA407=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format23x5143); 12859 stream_COMMA.add(COMMA407); 12860 12861 REGISTER408=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format23x5145); 12862 stream_REGISTER.add(REGISTER408); 12863 12864 COMMA409=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format23x5147); 12865 stream_COMMA.add(COMMA409); 12866 12867 REGISTER410=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format23x5149); 12868 stream_REGISTER.add(REGISTER410); 12869 12870 // AST REWRITE 12871 // elements: REGISTER, INSTRUCTION_FORMAT23x, REGISTER, REGISTER 12872 // token labels: 12873 // rule labels: retval 12874 // token list labels: 12875 // rule list labels: 12876 // wildcard labels: 12877 retval.tree = root_0; 12878 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12879 12880 root_0 = (CommonTree)adaptor.nil(); 12881 // 1016:5: -> ^( I_STATEMENT_FORMAT23x[$start, \"I_STATEMENT_FORMAT23x\"] INSTRUCTION_FORMAT23x REGISTER REGISTER REGISTER ) 12882 { 12883 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1016:8: ^( I_STATEMENT_FORMAT23x[$start, \"I_STATEMENT_FORMAT23x\"] INSTRUCTION_FORMAT23x REGISTER REGISTER REGISTER ) 12884 { 12885 CommonTree root_1 = (CommonTree)adaptor.nil(); 12886 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT23x, (retval.start), "I_STATEMENT_FORMAT23x"), root_1); 12887 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT23x.nextNode()); 12888 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12889 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12890 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12891 adaptor.addChild(root_0, root_1); 12892 } 12893 12894 } 12895 12896 12897 retval.tree = root_0; 12898 12899 } 12900 12901 retval.stop = input.LT(-1); 12902 12903 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12904 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12905 12906 } 12907 catch (RecognitionException re) { 12908 reportError(re); 12909 recover(input,re); 12910 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12911 } 12912 finally { 12913 // do for sure before leaving 12914 } 12915 return retval; 12916 } 12917 // $ANTLR end "insn_format23x" 12918 12919 12920 public static class insn_format25x_return extends ParserRuleReturnScope { 12921 CommonTree tree; 12922 @Override getTree()12923 public CommonTree getTree() { return tree; } 12924 }; 12925 12926 12927 // $ANTLR start "insn_format25x" 12928 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1018:1: insn_format25x : INSTRUCTION_FORMAT25x REGISTER COMMA OPEN_BRACE register_list CLOSE_BRACE -> ^( I_STATEMENT_FORMAT25x[$start, \"I_STATEMENT_FORMAT25x\"] INSTRUCTION_FORMAT25x REGISTER register_list ) ; insn_format25x()12929 public final smaliParser.insn_format25x_return insn_format25x() throws RecognitionException { 12930 smaliParser.insn_format25x_return retval = new smaliParser.insn_format25x_return(); 12931 retval.start = input.LT(1); 12932 12933 CommonTree root_0 = null; 12934 12935 Token INSTRUCTION_FORMAT25x411=null; 12936 Token REGISTER412=null; 12937 Token COMMA413=null; 12938 Token OPEN_BRACE414=null; 12939 Token CLOSE_BRACE416=null; 12940 ParserRuleReturnScope register_list415 =null; 12941 12942 CommonTree INSTRUCTION_FORMAT25x411_tree=null; 12943 CommonTree REGISTER412_tree=null; 12944 CommonTree COMMA413_tree=null; 12945 CommonTree OPEN_BRACE414_tree=null; 12946 CommonTree CLOSE_BRACE416_tree=null; 12947 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT25x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT25x"); 12948 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 12949 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12950 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12951 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 12952 RewriteRuleSubtreeStream stream_register_list=new RewriteRuleSubtreeStream(adaptor,"rule register_list"); 12953 12954 try { 12955 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1019:3: ( INSTRUCTION_FORMAT25x REGISTER COMMA OPEN_BRACE register_list CLOSE_BRACE -> ^( I_STATEMENT_FORMAT25x[$start, \"I_STATEMENT_FORMAT25x\"] INSTRUCTION_FORMAT25x REGISTER register_list ) ) 12956 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1020:5: INSTRUCTION_FORMAT25x REGISTER COMMA OPEN_BRACE register_list CLOSE_BRACE 12957 { 12958 INSTRUCTION_FORMAT25x411=(Token)match(input,INSTRUCTION_FORMAT25x,FOLLOW_INSTRUCTION_FORMAT25x_in_insn_format25x5183); 12959 stream_INSTRUCTION_FORMAT25x.add(INSTRUCTION_FORMAT25x411); 12960 12961 REGISTER412=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format25x5185); 12962 stream_REGISTER.add(REGISTER412); 12963 12964 COMMA413=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format25x5187); 12965 stream_COMMA.add(COMMA413); 12966 12967 OPEN_BRACE414=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format25x5189); 12968 stream_OPEN_BRACE.add(OPEN_BRACE414); 12969 12970 pushFollow(FOLLOW_register_list_in_insn_format25x5191); 12971 register_list415=register_list(); 12972 state._fsp--; 12973 12974 stream_register_list.add(register_list415.getTree()); 12975 CLOSE_BRACE416=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format25x5193); 12976 stream_CLOSE_BRACE.add(CLOSE_BRACE416); 12977 12978 // AST REWRITE 12979 // elements: REGISTER, INSTRUCTION_FORMAT25x, register_list 12980 // token labels: 12981 // rule labels: retval 12982 // token list labels: 12983 // rule list labels: 12984 // wildcard labels: 12985 retval.tree = root_0; 12986 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12987 12988 root_0 = (CommonTree)adaptor.nil(); 12989 // 1021:5: -> ^( I_STATEMENT_FORMAT25x[$start, \"I_STATEMENT_FORMAT25x\"] INSTRUCTION_FORMAT25x REGISTER register_list ) 12990 { 12991 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1021:8: ^( I_STATEMENT_FORMAT25x[$start, \"I_STATEMENT_FORMAT25x\"] INSTRUCTION_FORMAT25x REGISTER register_list ) 12992 { 12993 CommonTree root_1 = (CommonTree)adaptor.nil(); 12994 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT25x, (retval.start), "I_STATEMENT_FORMAT25x"), root_1); 12995 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT25x.nextNode()); 12996 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12997 adaptor.addChild(root_1, stream_register_list.nextTree()); 12998 adaptor.addChild(root_0, root_1); 12999 } 13000 13001 } 13002 13003 13004 retval.tree = root_0; 13005 13006 } 13007 13008 retval.stop = input.LT(-1); 13009 13010 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13011 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13012 13013 } 13014 catch (RecognitionException re) { 13015 reportError(re); 13016 recover(input,re); 13017 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13018 } 13019 finally { 13020 // do for sure before leaving 13021 } 13022 return retval; 13023 } 13024 // $ANTLR end "insn_format25x" 13025 13026 13027 public static class insn_format30t_return extends ParserRuleReturnScope { 13028 CommonTree tree; 13029 @Override getTree()13030 public CommonTree getTree() { return tree; } 13031 }; 13032 13033 13034 // $ANTLR start "insn_format30t" 13035 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1023:1: insn_format30t : INSTRUCTION_FORMAT30t label_ref -> ^( I_STATEMENT_FORMAT30t[$start, \"I_STATEMENT_FORMAT30t\"] INSTRUCTION_FORMAT30t label_ref ) ; insn_format30t()13036 public final smaliParser.insn_format30t_return insn_format30t() throws RecognitionException { 13037 smaliParser.insn_format30t_return retval = new smaliParser.insn_format30t_return(); 13038 retval.start = input.LT(1); 13039 13040 CommonTree root_0 = null; 13041 13042 Token INSTRUCTION_FORMAT30t417=null; 13043 ParserRuleReturnScope label_ref418 =null; 13044 13045 CommonTree INSTRUCTION_FORMAT30t417_tree=null; 13046 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT30t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT30t"); 13047 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 13048 13049 try { 13050 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1024:3: ( INSTRUCTION_FORMAT30t label_ref -> ^( I_STATEMENT_FORMAT30t[$start, \"I_STATEMENT_FORMAT30t\"] INSTRUCTION_FORMAT30t label_ref ) ) 13051 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1025:5: INSTRUCTION_FORMAT30t label_ref 13052 { 13053 INSTRUCTION_FORMAT30t417=(Token)match(input,INSTRUCTION_FORMAT30t,FOLLOW_INSTRUCTION_FORMAT30t_in_insn_format30t5225); 13054 stream_INSTRUCTION_FORMAT30t.add(INSTRUCTION_FORMAT30t417); 13055 13056 pushFollow(FOLLOW_label_ref_in_insn_format30t5227); 13057 label_ref418=label_ref(); 13058 state._fsp--; 13059 13060 stream_label_ref.add(label_ref418.getTree()); 13061 // AST REWRITE 13062 // elements: label_ref, INSTRUCTION_FORMAT30t 13063 // token labels: 13064 // rule labels: retval 13065 // token list labels: 13066 // rule list labels: 13067 // wildcard labels: 13068 retval.tree = root_0; 13069 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 13070 13071 root_0 = (CommonTree)adaptor.nil(); 13072 // 1026:5: -> ^( I_STATEMENT_FORMAT30t[$start, \"I_STATEMENT_FORMAT30t\"] INSTRUCTION_FORMAT30t label_ref ) 13073 { 13074 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1026:8: ^( I_STATEMENT_FORMAT30t[$start, \"I_STATEMENT_FORMAT30t\"] INSTRUCTION_FORMAT30t label_ref ) 13075 { 13076 CommonTree root_1 = (CommonTree)adaptor.nil(); 13077 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT30t, (retval.start), "I_STATEMENT_FORMAT30t"), root_1); 13078 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT30t.nextNode()); 13079 adaptor.addChild(root_1, stream_label_ref.nextTree()); 13080 adaptor.addChild(root_0, root_1); 13081 } 13082 13083 } 13084 13085 13086 retval.tree = root_0; 13087 13088 } 13089 13090 retval.stop = input.LT(-1); 13091 13092 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13093 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13094 13095 } 13096 catch (RecognitionException re) { 13097 reportError(re); 13098 recover(input,re); 13099 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13100 } 13101 finally { 13102 // do for sure before leaving 13103 } 13104 return retval; 13105 } 13106 // $ANTLR end "insn_format30t" 13107 13108 13109 public static class insn_format31c_return extends ParserRuleReturnScope { 13110 CommonTree tree; 13111 @Override getTree()13112 public CommonTree getTree() { return tree; } 13113 }; 13114 13115 13116 // $ANTLR start "insn_format31c" 13117 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1028:1: insn_format31c : INSTRUCTION_FORMAT31c REGISTER COMMA STRING_LITERAL -> ^( I_STATEMENT_FORMAT31c[$start, \"I_STATEMENT_FORMAT31c\"] INSTRUCTION_FORMAT31c REGISTER STRING_LITERAL ) ; insn_format31c()13118 public final smaliParser.insn_format31c_return insn_format31c() throws RecognitionException { 13119 smaliParser.insn_format31c_return retval = new smaliParser.insn_format31c_return(); 13120 retval.start = input.LT(1); 13121 13122 CommonTree root_0 = null; 13123 13124 Token INSTRUCTION_FORMAT31c419=null; 13125 Token REGISTER420=null; 13126 Token COMMA421=null; 13127 Token STRING_LITERAL422=null; 13128 13129 CommonTree INSTRUCTION_FORMAT31c419_tree=null; 13130 CommonTree REGISTER420_tree=null; 13131 CommonTree COMMA421_tree=null; 13132 CommonTree STRING_LITERAL422_tree=null; 13133 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT31c=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT31c"); 13134 RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL"); 13135 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 13136 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 13137 13138 try { 13139 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1029:3: ( INSTRUCTION_FORMAT31c REGISTER COMMA STRING_LITERAL -> ^( I_STATEMENT_FORMAT31c[$start, \"I_STATEMENT_FORMAT31c\"] INSTRUCTION_FORMAT31c REGISTER STRING_LITERAL ) ) 13140 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1030:5: INSTRUCTION_FORMAT31c REGISTER COMMA STRING_LITERAL 13141 { 13142 INSTRUCTION_FORMAT31c419=(Token)match(input,INSTRUCTION_FORMAT31c,FOLLOW_INSTRUCTION_FORMAT31c_in_insn_format31c5257); 13143 stream_INSTRUCTION_FORMAT31c.add(INSTRUCTION_FORMAT31c419); 13144 13145 REGISTER420=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format31c5259); 13146 stream_REGISTER.add(REGISTER420); 13147 13148 COMMA421=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format31c5261); 13149 stream_COMMA.add(COMMA421); 13150 13151 STRING_LITERAL422=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_insn_format31c5263); 13152 stream_STRING_LITERAL.add(STRING_LITERAL422); 13153 13154 // AST REWRITE 13155 // elements: STRING_LITERAL, INSTRUCTION_FORMAT31c, REGISTER 13156 // token labels: 13157 // rule labels: retval 13158 // token list labels: 13159 // rule list labels: 13160 // wildcard labels: 13161 retval.tree = root_0; 13162 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 13163 13164 root_0 = (CommonTree)adaptor.nil(); 13165 // 1031:5: -> ^( I_STATEMENT_FORMAT31c[$start, \"I_STATEMENT_FORMAT31c\"] INSTRUCTION_FORMAT31c REGISTER STRING_LITERAL ) 13166 { 13167 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1031:7: ^( I_STATEMENT_FORMAT31c[$start, \"I_STATEMENT_FORMAT31c\"] INSTRUCTION_FORMAT31c REGISTER STRING_LITERAL ) 13168 { 13169 CommonTree root_1 = (CommonTree)adaptor.nil(); 13170 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT31c, (retval.start), "I_STATEMENT_FORMAT31c"), root_1); 13171 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT31c.nextNode()); 13172 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 13173 adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode()); 13174 adaptor.addChild(root_0, root_1); 13175 } 13176 13177 } 13178 13179 13180 retval.tree = root_0; 13181 13182 } 13183 13184 retval.stop = input.LT(-1); 13185 13186 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13187 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13188 13189 } 13190 catch (RecognitionException re) { 13191 reportError(re); 13192 recover(input,re); 13193 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13194 } 13195 finally { 13196 // do for sure before leaving 13197 } 13198 return retval; 13199 } 13200 // $ANTLR end "insn_format31c" 13201 13202 13203 public static class insn_format31i_return extends ParserRuleReturnScope { 13204 CommonTree tree; 13205 @Override getTree()13206 public CommonTree getTree() { return tree; } 13207 }; 13208 13209 13210 // $ANTLR start "insn_format31i" 13211 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1033:1: insn_format31i : instruction_format31i REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT31i[$start, \"I_STATEMENT_FORMAT31i\"] instruction_format31i REGISTER fixed_32bit_literal ) ; insn_format31i()13212 public final smaliParser.insn_format31i_return insn_format31i() throws RecognitionException { 13213 smaliParser.insn_format31i_return retval = new smaliParser.insn_format31i_return(); 13214 retval.start = input.LT(1); 13215 13216 CommonTree root_0 = null; 13217 13218 Token REGISTER424=null; 13219 Token COMMA425=null; 13220 ParserRuleReturnScope instruction_format31i423 =null; 13221 ParserRuleReturnScope fixed_32bit_literal426 =null; 13222 13223 CommonTree REGISTER424_tree=null; 13224 CommonTree COMMA425_tree=null; 13225 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 13226 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 13227 RewriteRuleSubtreeStream stream_instruction_format31i=new RewriteRuleSubtreeStream(adaptor,"rule instruction_format31i"); 13228 RewriteRuleSubtreeStream stream_fixed_32bit_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_32bit_literal"); 13229 13230 try { 13231 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1034:3: ( instruction_format31i REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT31i[$start, \"I_STATEMENT_FORMAT31i\"] instruction_format31i REGISTER fixed_32bit_literal ) ) 13232 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1035:5: instruction_format31i REGISTER COMMA fixed_32bit_literal 13233 { 13234 pushFollow(FOLLOW_instruction_format31i_in_insn_format31i5294); 13235 instruction_format31i423=instruction_format31i(); 13236 state._fsp--; 13237 13238 stream_instruction_format31i.add(instruction_format31i423.getTree()); 13239 REGISTER424=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format31i5296); 13240 stream_REGISTER.add(REGISTER424); 13241 13242 COMMA425=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format31i5298); 13243 stream_COMMA.add(COMMA425); 13244 13245 pushFollow(FOLLOW_fixed_32bit_literal_in_insn_format31i5300); 13246 fixed_32bit_literal426=fixed_32bit_literal(); 13247 state._fsp--; 13248 13249 stream_fixed_32bit_literal.add(fixed_32bit_literal426.getTree()); 13250 // AST REWRITE 13251 // elements: instruction_format31i, REGISTER, fixed_32bit_literal 13252 // token labels: 13253 // rule labels: retval 13254 // token list labels: 13255 // rule list labels: 13256 // wildcard labels: 13257 retval.tree = root_0; 13258 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 13259 13260 root_0 = (CommonTree)adaptor.nil(); 13261 // 1036:5: -> ^( I_STATEMENT_FORMAT31i[$start, \"I_STATEMENT_FORMAT31i\"] instruction_format31i REGISTER fixed_32bit_literal ) 13262 { 13263 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1036:8: ^( I_STATEMENT_FORMAT31i[$start, \"I_STATEMENT_FORMAT31i\"] instruction_format31i REGISTER fixed_32bit_literal ) 13264 { 13265 CommonTree root_1 = (CommonTree)adaptor.nil(); 13266 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT31i, (retval.start), "I_STATEMENT_FORMAT31i"), root_1); 13267 adaptor.addChild(root_1, stream_instruction_format31i.nextTree()); 13268 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 13269 adaptor.addChild(root_1, stream_fixed_32bit_literal.nextTree()); 13270 adaptor.addChild(root_0, root_1); 13271 } 13272 13273 } 13274 13275 13276 retval.tree = root_0; 13277 13278 } 13279 13280 retval.stop = input.LT(-1); 13281 13282 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13283 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13284 13285 } 13286 catch (RecognitionException re) { 13287 reportError(re); 13288 recover(input,re); 13289 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13290 } 13291 finally { 13292 // do for sure before leaving 13293 } 13294 return retval; 13295 } 13296 // $ANTLR end "insn_format31i" 13297 13298 13299 public static class insn_format31t_return extends ParserRuleReturnScope { 13300 CommonTree tree; 13301 @Override getTree()13302 public CommonTree getTree() { return tree; } 13303 }; 13304 13305 13306 // $ANTLR start "insn_format31t" 13307 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1038:1: insn_format31t : INSTRUCTION_FORMAT31t REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT31t[$start, \"I_STATEMENT_FORMAT31t\"] INSTRUCTION_FORMAT31t REGISTER label_ref ) ; insn_format31t()13308 public final smaliParser.insn_format31t_return insn_format31t() throws RecognitionException { 13309 smaliParser.insn_format31t_return retval = new smaliParser.insn_format31t_return(); 13310 retval.start = input.LT(1); 13311 13312 CommonTree root_0 = null; 13313 13314 Token INSTRUCTION_FORMAT31t427=null; 13315 Token REGISTER428=null; 13316 Token COMMA429=null; 13317 ParserRuleReturnScope label_ref430 =null; 13318 13319 CommonTree INSTRUCTION_FORMAT31t427_tree=null; 13320 CommonTree REGISTER428_tree=null; 13321 CommonTree COMMA429_tree=null; 13322 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT31t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT31t"); 13323 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 13324 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 13325 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 13326 13327 try { 13328 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1039:3: ( INSTRUCTION_FORMAT31t REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT31t[$start, \"I_STATEMENT_FORMAT31t\"] INSTRUCTION_FORMAT31t REGISTER label_ref ) ) 13329 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1040:5: INSTRUCTION_FORMAT31t REGISTER COMMA label_ref 13330 { 13331 INSTRUCTION_FORMAT31t427=(Token)match(input,INSTRUCTION_FORMAT31t,FOLLOW_INSTRUCTION_FORMAT31t_in_insn_format31t5332); 13332 stream_INSTRUCTION_FORMAT31t.add(INSTRUCTION_FORMAT31t427); 13333 13334 REGISTER428=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format31t5334); 13335 stream_REGISTER.add(REGISTER428); 13336 13337 COMMA429=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format31t5336); 13338 stream_COMMA.add(COMMA429); 13339 13340 pushFollow(FOLLOW_label_ref_in_insn_format31t5338); 13341 label_ref430=label_ref(); 13342 state._fsp--; 13343 13344 stream_label_ref.add(label_ref430.getTree()); 13345 // AST REWRITE 13346 // elements: REGISTER, label_ref, INSTRUCTION_FORMAT31t 13347 // token labels: 13348 // rule labels: retval 13349 // token list labels: 13350 // rule list labels: 13351 // wildcard labels: 13352 retval.tree = root_0; 13353 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 13354 13355 root_0 = (CommonTree)adaptor.nil(); 13356 // 1041:5: -> ^( I_STATEMENT_FORMAT31t[$start, \"I_STATEMENT_FORMAT31t\"] INSTRUCTION_FORMAT31t REGISTER label_ref ) 13357 { 13358 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1041:8: ^( I_STATEMENT_FORMAT31t[$start, \"I_STATEMENT_FORMAT31t\"] INSTRUCTION_FORMAT31t REGISTER label_ref ) 13359 { 13360 CommonTree root_1 = (CommonTree)adaptor.nil(); 13361 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT31t, (retval.start), "I_STATEMENT_FORMAT31t"), root_1); 13362 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT31t.nextNode()); 13363 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 13364 adaptor.addChild(root_1, stream_label_ref.nextTree()); 13365 adaptor.addChild(root_0, root_1); 13366 } 13367 13368 } 13369 13370 13371 retval.tree = root_0; 13372 13373 } 13374 13375 retval.stop = input.LT(-1); 13376 13377 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13378 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13379 13380 } 13381 catch (RecognitionException re) { 13382 reportError(re); 13383 recover(input,re); 13384 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13385 } 13386 finally { 13387 // do for sure before leaving 13388 } 13389 return retval; 13390 } 13391 // $ANTLR end "insn_format31t" 13392 13393 13394 public static class insn_format32x_return extends ParserRuleReturnScope { 13395 CommonTree tree; 13396 @Override getTree()13397 public CommonTree getTree() { return tree; } 13398 }; 13399 13400 13401 // $ANTLR start "insn_format32x" 13402 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1043:1: insn_format32x : INSTRUCTION_FORMAT32x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT32x[$start, \"I_STATEMENT_FORMAT32x\"] INSTRUCTION_FORMAT32x REGISTER REGISTER ) ; insn_format32x()13403 public final smaliParser.insn_format32x_return insn_format32x() throws RecognitionException { 13404 smaliParser.insn_format32x_return retval = new smaliParser.insn_format32x_return(); 13405 retval.start = input.LT(1); 13406 13407 CommonTree root_0 = null; 13408 13409 Token INSTRUCTION_FORMAT32x431=null; 13410 Token REGISTER432=null; 13411 Token COMMA433=null; 13412 Token REGISTER434=null; 13413 13414 CommonTree INSTRUCTION_FORMAT32x431_tree=null; 13415 CommonTree REGISTER432_tree=null; 13416 CommonTree COMMA433_tree=null; 13417 CommonTree REGISTER434_tree=null; 13418 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 13419 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 13420 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT32x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT32x"); 13421 13422 try { 13423 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1044:3: ( INSTRUCTION_FORMAT32x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT32x[$start, \"I_STATEMENT_FORMAT32x\"] INSTRUCTION_FORMAT32x REGISTER REGISTER ) ) 13424 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1045:5: INSTRUCTION_FORMAT32x REGISTER COMMA REGISTER 13425 { 13426 INSTRUCTION_FORMAT32x431=(Token)match(input,INSTRUCTION_FORMAT32x,FOLLOW_INSTRUCTION_FORMAT32x_in_insn_format32x5370); 13427 stream_INSTRUCTION_FORMAT32x.add(INSTRUCTION_FORMAT32x431); 13428 13429 REGISTER432=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format32x5372); 13430 stream_REGISTER.add(REGISTER432); 13431 13432 COMMA433=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format32x5374); 13433 stream_COMMA.add(COMMA433); 13434 13435 REGISTER434=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format32x5376); 13436 stream_REGISTER.add(REGISTER434); 13437 13438 // AST REWRITE 13439 // elements: INSTRUCTION_FORMAT32x, REGISTER, REGISTER 13440 // token labels: 13441 // rule labels: retval 13442 // token list labels: 13443 // rule list labels: 13444 // wildcard labels: 13445 retval.tree = root_0; 13446 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 13447 13448 root_0 = (CommonTree)adaptor.nil(); 13449 // 1046:5: -> ^( I_STATEMENT_FORMAT32x[$start, \"I_STATEMENT_FORMAT32x\"] INSTRUCTION_FORMAT32x REGISTER REGISTER ) 13450 { 13451 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1046:8: ^( I_STATEMENT_FORMAT32x[$start, \"I_STATEMENT_FORMAT32x\"] INSTRUCTION_FORMAT32x REGISTER REGISTER ) 13452 { 13453 CommonTree root_1 = (CommonTree)adaptor.nil(); 13454 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT32x, (retval.start), "I_STATEMENT_FORMAT32x"), root_1); 13455 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT32x.nextNode()); 13456 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 13457 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 13458 adaptor.addChild(root_0, root_1); 13459 } 13460 13461 } 13462 13463 13464 retval.tree = root_0; 13465 13466 } 13467 13468 retval.stop = input.LT(-1); 13469 13470 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13471 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13472 13473 } 13474 catch (RecognitionException re) { 13475 reportError(re); 13476 recover(input,re); 13477 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13478 } 13479 finally { 13480 // do for sure before leaving 13481 } 13482 return retval; 13483 } 13484 // $ANTLR end "insn_format32x" 13485 13486 13487 public static class insn_format35c_method_return extends ParserRuleReturnScope { 13488 CommonTree tree; 13489 @Override getTree()13490 public CommonTree getTree() { return tree; } 13491 }; 13492 13493 13494 // $ANTLR start "insn_format35c_method" 13495 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1048: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 ) ; insn_format35c_method()13496 public final smaliParser.insn_format35c_method_return insn_format35c_method() throws RecognitionException { 13497 smaliParser.insn_format35c_method_return retval = new smaliParser.insn_format35c_method_return(); 13498 retval.start = input.LT(1); 13499 13500 CommonTree root_0 = null; 13501 13502 Token INSTRUCTION_FORMAT35c_METHOD435=null; 13503 Token OPEN_BRACE436=null; 13504 Token CLOSE_BRACE438=null; 13505 Token COMMA439=null; 13506 ParserRuleReturnScope register_list437 =null; 13507 ParserRuleReturnScope method_reference440 =null; 13508 13509 CommonTree INSTRUCTION_FORMAT35c_METHOD435_tree=null; 13510 CommonTree OPEN_BRACE436_tree=null; 13511 CommonTree CLOSE_BRACE438_tree=null; 13512 CommonTree COMMA439_tree=null; 13513 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35c_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35c_METHOD"); 13514 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 13515 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 13516 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 13517 RewriteRuleSubtreeStream stream_register_list=new RewriteRuleSubtreeStream(adaptor,"rule register_list"); 13518 RewriteRuleSubtreeStream stream_method_reference=new RewriteRuleSubtreeStream(adaptor,"rule method_reference"); 13519 13520 try { 13521 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1049: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 ) ) 13522 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1050:5: INSTRUCTION_FORMAT35c_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference 13523 { 13524 INSTRUCTION_FORMAT35c_METHOD435=(Token)match(input,INSTRUCTION_FORMAT35c_METHOD,FOLLOW_INSTRUCTION_FORMAT35c_METHOD_in_insn_format35c_method5408); 13525 stream_INSTRUCTION_FORMAT35c_METHOD.add(INSTRUCTION_FORMAT35c_METHOD435); 13526 13527 OPEN_BRACE436=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format35c_method5410); 13528 stream_OPEN_BRACE.add(OPEN_BRACE436); 13529 13530 pushFollow(FOLLOW_register_list_in_insn_format35c_method5412); 13531 register_list437=register_list(); 13532 state._fsp--; 13533 13534 stream_register_list.add(register_list437.getTree()); 13535 CLOSE_BRACE438=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format35c_method5414); 13536 stream_CLOSE_BRACE.add(CLOSE_BRACE438); 13537 13538 COMMA439=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format35c_method5416); 13539 stream_COMMA.add(COMMA439); 13540 13541 pushFollow(FOLLOW_method_reference_in_insn_format35c_method5418); 13542 method_reference440=method_reference(); 13543 state._fsp--; 13544 13545 stream_method_reference.add(method_reference440.getTree()); 13546 // AST REWRITE 13547 // elements: INSTRUCTION_FORMAT35c_METHOD, method_reference, register_list 13548 // token labels: 13549 // rule labels: retval 13550 // token list labels: 13551 // rule list labels: 13552 // wildcard labels: 13553 retval.tree = root_0; 13554 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 13555 13556 root_0 = (CommonTree)adaptor.nil(); 13557 // 1051:5: -> ^( I_STATEMENT_FORMAT35c_METHOD[$start, \"I_STATEMENT_FORMAT35c_METHOD\"] INSTRUCTION_FORMAT35c_METHOD register_list method_reference ) 13558 { 13559 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1051:8: ^( I_STATEMENT_FORMAT35c_METHOD[$start, \"I_STATEMENT_FORMAT35c_METHOD\"] INSTRUCTION_FORMAT35c_METHOD register_list method_reference ) 13560 { 13561 CommonTree root_1 = (CommonTree)adaptor.nil(); 13562 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT35c_METHOD, (retval.start), "I_STATEMENT_FORMAT35c_METHOD"), root_1); 13563 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT35c_METHOD.nextNode()); 13564 adaptor.addChild(root_1, stream_register_list.nextTree()); 13565 adaptor.addChild(root_1, stream_method_reference.nextTree()); 13566 adaptor.addChild(root_0, root_1); 13567 } 13568 13569 } 13570 13571 13572 retval.tree = root_0; 13573 13574 } 13575 13576 retval.stop = input.LT(-1); 13577 13578 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13579 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13580 13581 } 13582 catch (RecognitionException re) { 13583 reportError(re); 13584 recover(input,re); 13585 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13586 } 13587 finally { 13588 // do for sure before leaving 13589 } 13590 return retval; 13591 } 13592 // $ANTLR end "insn_format35c_method" 13593 13594 13595 public static class insn_format35c_type_return extends ParserRuleReturnScope { 13596 CommonTree tree; 13597 @Override getTree()13598 public CommonTree getTree() { return tree; } 13599 }; 13600 13601 13602 // $ANTLR start "insn_format35c_type" 13603 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1053: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 ) ; insn_format35c_type()13604 public final smaliParser.insn_format35c_type_return insn_format35c_type() throws RecognitionException { 13605 smaliParser.insn_format35c_type_return retval = new smaliParser.insn_format35c_type_return(); 13606 retval.start = input.LT(1); 13607 13608 CommonTree root_0 = null; 13609 13610 Token INSTRUCTION_FORMAT35c_TYPE441=null; 13611 Token OPEN_BRACE442=null; 13612 Token CLOSE_BRACE444=null; 13613 Token COMMA445=null; 13614 ParserRuleReturnScope register_list443 =null; 13615 ParserRuleReturnScope nonvoid_type_descriptor446 =null; 13616 13617 CommonTree INSTRUCTION_FORMAT35c_TYPE441_tree=null; 13618 CommonTree OPEN_BRACE442_tree=null; 13619 CommonTree CLOSE_BRACE444_tree=null; 13620 CommonTree COMMA445_tree=null; 13621 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 13622 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 13623 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 13624 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35c_TYPE"); 13625 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 13626 RewriteRuleSubtreeStream stream_register_list=new RewriteRuleSubtreeStream(adaptor,"rule register_list"); 13627 13628 try { 13629 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1054: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 ) ) 13630 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1055:5: INSTRUCTION_FORMAT35c_TYPE OPEN_BRACE register_list CLOSE_BRACE COMMA nonvoid_type_descriptor 13631 { 13632 INSTRUCTION_FORMAT35c_TYPE441=(Token)match(input,INSTRUCTION_FORMAT35c_TYPE,FOLLOW_INSTRUCTION_FORMAT35c_TYPE_in_insn_format35c_type5450); 13633 stream_INSTRUCTION_FORMAT35c_TYPE.add(INSTRUCTION_FORMAT35c_TYPE441); 13634 13635 OPEN_BRACE442=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format35c_type5452); 13636 stream_OPEN_BRACE.add(OPEN_BRACE442); 13637 13638 pushFollow(FOLLOW_register_list_in_insn_format35c_type5454); 13639 register_list443=register_list(); 13640 state._fsp--; 13641 13642 stream_register_list.add(register_list443.getTree()); 13643 CLOSE_BRACE444=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format35c_type5456); 13644 stream_CLOSE_BRACE.add(CLOSE_BRACE444); 13645 13646 COMMA445=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format35c_type5458); 13647 stream_COMMA.add(COMMA445); 13648 13649 pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format35c_type5460); 13650 nonvoid_type_descriptor446=nonvoid_type_descriptor(); 13651 state._fsp--; 13652 13653 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor446.getTree()); 13654 // AST REWRITE 13655 // elements: nonvoid_type_descriptor, register_list, INSTRUCTION_FORMAT35c_TYPE 13656 // token labels: 13657 // rule labels: retval 13658 // token list labels: 13659 // rule list labels: 13660 // wildcard labels: 13661 retval.tree = root_0; 13662 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 13663 13664 root_0 = (CommonTree)adaptor.nil(); 13665 // 1056:5: -> ^( I_STATEMENT_FORMAT35c_TYPE[$start, \"I_STATEMENT_FORMAT35c_TYPE\"] INSTRUCTION_FORMAT35c_TYPE register_list nonvoid_type_descriptor ) 13666 { 13667 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1056:8: ^( I_STATEMENT_FORMAT35c_TYPE[$start, \"I_STATEMENT_FORMAT35c_TYPE\"] INSTRUCTION_FORMAT35c_TYPE register_list nonvoid_type_descriptor ) 13668 { 13669 CommonTree root_1 = (CommonTree)adaptor.nil(); 13670 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT35c_TYPE, (retval.start), "I_STATEMENT_FORMAT35c_TYPE"), root_1); 13671 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT35c_TYPE.nextNode()); 13672 adaptor.addChild(root_1, stream_register_list.nextTree()); 13673 adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree()); 13674 adaptor.addChild(root_0, root_1); 13675 } 13676 13677 } 13678 13679 13680 retval.tree = root_0; 13681 13682 } 13683 13684 retval.stop = input.LT(-1); 13685 13686 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13687 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13688 13689 } 13690 catch (RecognitionException re) { 13691 reportError(re); 13692 recover(input,re); 13693 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13694 } 13695 finally { 13696 // do for sure before leaving 13697 } 13698 return retval; 13699 } 13700 // $ANTLR end "insn_format35c_type" 13701 13702 13703 public static class insn_format35c_method_odex_return extends ParserRuleReturnScope { 13704 CommonTree tree; 13705 @Override getTree()13706 public CommonTree getTree() { return tree; } 13707 }; 13708 13709 13710 // $ANTLR start "insn_format35c_method_odex" 13711 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1058:1: insn_format35c_method_odex : INSTRUCTION_FORMAT35c_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference ; insn_format35c_method_odex()13712 public final smaliParser.insn_format35c_method_odex_return insn_format35c_method_odex() throws RecognitionException { 13713 smaliParser.insn_format35c_method_odex_return retval = new smaliParser.insn_format35c_method_odex_return(); 13714 retval.start = input.LT(1); 13715 13716 CommonTree root_0 = null; 13717 13718 Token INSTRUCTION_FORMAT35c_METHOD_ODEX447=null; 13719 Token OPEN_BRACE448=null; 13720 Token CLOSE_BRACE450=null; 13721 Token COMMA451=null; 13722 ParserRuleReturnScope register_list449 =null; 13723 ParserRuleReturnScope method_reference452 =null; 13724 13725 CommonTree INSTRUCTION_FORMAT35c_METHOD_ODEX447_tree=null; 13726 CommonTree OPEN_BRACE448_tree=null; 13727 CommonTree CLOSE_BRACE450_tree=null; 13728 CommonTree COMMA451_tree=null; 13729 13730 try { 13731 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1059:3: ( INSTRUCTION_FORMAT35c_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference ) 13732 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1060:5: INSTRUCTION_FORMAT35c_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference 13733 { 13734 root_0 = (CommonTree)adaptor.nil(); 13735 13736 13737 INSTRUCTION_FORMAT35c_METHOD_ODEX447=(Token)match(input,INSTRUCTION_FORMAT35c_METHOD_ODEX,FOLLOW_INSTRUCTION_FORMAT35c_METHOD_ODEX_in_insn_format35c_method_odex5492); 13738 INSTRUCTION_FORMAT35c_METHOD_ODEX447_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT35c_METHOD_ODEX447); 13739 adaptor.addChild(root_0, INSTRUCTION_FORMAT35c_METHOD_ODEX447_tree); 13740 13741 OPEN_BRACE448=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format35c_method_odex5494); 13742 OPEN_BRACE448_tree = (CommonTree)adaptor.create(OPEN_BRACE448); 13743 adaptor.addChild(root_0, OPEN_BRACE448_tree); 13744 13745 pushFollow(FOLLOW_register_list_in_insn_format35c_method_odex5496); 13746 register_list449=register_list(); 13747 state._fsp--; 13748 13749 adaptor.addChild(root_0, register_list449.getTree()); 13750 13751 CLOSE_BRACE450=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format35c_method_odex5498); 13752 CLOSE_BRACE450_tree = (CommonTree)adaptor.create(CLOSE_BRACE450); 13753 adaptor.addChild(root_0, CLOSE_BRACE450_tree); 13754 13755 COMMA451=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format35c_method_odex5500); 13756 COMMA451_tree = (CommonTree)adaptor.create(COMMA451); 13757 adaptor.addChild(root_0, COMMA451_tree); 13758 13759 pushFollow(FOLLOW_method_reference_in_insn_format35c_method_odex5502); 13760 method_reference452=method_reference(); 13761 state._fsp--; 13762 13763 adaptor.addChild(root_0, method_reference452.getTree()); 13764 13765 13766 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT35c_METHOD_ODEX447!=null?INSTRUCTION_FORMAT35c_METHOD_ODEX447.getText():null)); 13767 13768 } 13769 13770 retval.stop = input.LT(-1); 13771 13772 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13773 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13774 13775 } 13776 catch (RecognitionException re) { 13777 reportError(re); 13778 recover(input,re); 13779 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13780 } 13781 finally { 13782 // do for sure before leaving 13783 } 13784 return retval; 13785 } 13786 // $ANTLR end "insn_format35c_method_odex" 13787 13788 13789 public static class insn_format35mi_method_return extends ParserRuleReturnScope { 13790 CommonTree tree; 13791 @Override getTree()13792 public CommonTree getTree() { return tree; } 13793 }; 13794 13795 13796 // $ANTLR start "insn_format35mi_method" 13797 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1065:1: insn_format35mi_method : INSTRUCTION_FORMAT35mi_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA INLINE_INDEX ; insn_format35mi_method()13798 public final smaliParser.insn_format35mi_method_return insn_format35mi_method() throws RecognitionException { 13799 smaliParser.insn_format35mi_method_return retval = new smaliParser.insn_format35mi_method_return(); 13800 retval.start = input.LT(1); 13801 13802 CommonTree root_0 = null; 13803 13804 Token INSTRUCTION_FORMAT35mi_METHOD453=null; 13805 Token OPEN_BRACE454=null; 13806 Token CLOSE_BRACE456=null; 13807 Token COMMA457=null; 13808 Token INLINE_INDEX458=null; 13809 ParserRuleReturnScope register_list455 =null; 13810 13811 CommonTree INSTRUCTION_FORMAT35mi_METHOD453_tree=null; 13812 CommonTree OPEN_BRACE454_tree=null; 13813 CommonTree CLOSE_BRACE456_tree=null; 13814 CommonTree COMMA457_tree=null; 13815 CommonTree INLINE_INDEX458_tree=null; 13816 13817 try { 13818 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1066:3: ( INSTRUCTION_FORMAT35mi_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA INLINE_INDEX ) 13819 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1067:5: INSTRUCTION_FORMAT35mi_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA INLINE_INDEX 13820 { 13821 root_0 = (CommonTree)adaptor.nil(); 13822 13823 13824 INSTRUCTION_FORMAT35mi_METHOD453=(Token)match(input,INSTRUCTION_FORMAT35mi_METHOD,FOLLOW_INSTRUCTION_FORMAT35mi_METHOD_in_insn_format35mi_method5523); 13825 INSTRUCTION_FORMAT35mi_METHOD453_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT35mi_METHOD453); 13826 adaptor.addChild(root_0, INSTRUCTION_FORMAT35mi_METHOD453_tree); 13827 13828 OPEN_BRACE454=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format35mi_method5525); 13829 OPEN_BRACE454_tree = (CommonTree)adaptor.create(OPEN_BRACE454); 13830 adaptor.addChild(root_0, OPEN_BRACE454_tree); 13831 13832 pushFollow(FOLLOW_register_list_in_insn_format35mi_method5527); 13833 register_list455=register_list(); 13834 state._fsp--; 13835 13836 adaptor.addChild(root_0, register_list455.getTree()); 13837 13838 CLOSE_BRACE456=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format35mi_method5529); 13839 CLOSE_BRACE456_tree = (CommonTree)adaptor.create(CLOSE_BRACE456); 13840 adaptor.addChild(root_0, CLOSE_BRACE456_tree); 13841 13842 COMMA457=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format35mi_method5531); 13843 COMMA457_tree = (CommonTree)adaptor.create(COMMA457); 13844 adaptor.addChild(root_0, COMMA457_tree); 13845 13846 INLINE_INDEX458=(Token)match(input,INLINE_INDEX,FOLLOW_INLINE_INDEX_in_insn_format35mi_method5533); 13847 INLINE_INDEX458_tree = (CommonTree)adaptor.create(INLINE_INDEX458); 13848 adaptor.addChild(root_0, INLINE_INDEX458_tree); 13849 13850 13851 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT35mi_METHOD453!=null?INSTRUCTION_FORMAT35mi_METHOD453.getText():null)); 13852 13853 } 13854 13855 retval.stop = input.LT(-1); 13856 13857 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13858 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13859 13860 } 13861 catch (RecognitionException re) { 13862 reportError(re); 13863 recover(input,re); 13864 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13865 } 13866 finally { 13867 // do for sure before leaving 13868 } 13869 return retval; 13870 } 13871 // $ANTLR end "insn_format35mi_method" 13872 13873 13874 public static class insn_format35ms_method_return extends ParserRuleReturnScope { 13875 CommonTree tree; 13876 @Override getTree()13877 public CommonTree getTree() { return tree; } 13878 }; 13879 13880 13881 // $ANTLR start "insn_format35ms_method" 13882 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1072:1: insn_format35ms_method : INSTRUCTION_FORMAT35ms_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA VTABLE_INDEX ; insn_format35ms_method()13883 public final smaliParser.insn_format35ms_method_return insn_format35ms_method() throws RecognitionException { 13884 smaliParser.insn_format35ms_method_return retval = new smaliParser.insn_format35ms_method_return(); 13885 retval.start = input.LT(1); 13886 13887 CommonTree root_0 = null; 13888 13889 Token INSTRUCTION_FORMAT35ms_METHOD459=null; 13890 Token OPEN_BRACE460=null; 13891 Token CLOSE_BRACE462=null; 13892 Token COMMA463=null; 13893 Token VTABLE_INDEX464=null; 13894 ParserRuleReturnScope register_list461 =null; 13895 13896 CommonTree INSTRUCTION_FORMAT35ms_METHOD459_tree=null; 13897 CommonTree OPEN_BRACE460_tree=null; 13898 CommonTree CLOSE_BRACE462_tree=null; 13899 CommonTree COMMA463_tree=null; 13900 CommonTree VTABLE_INDEX464_tree=null; 13901 13902 try { 13903 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1073:3: ( INSTRUCTION_FORMAT35ms_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA VTABLE_INDEX ) 13904 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1074:5: INSTRUCTION_FORMAT35ms_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA VTABLE_INDEX 13905 { 13906 root_0 = (CommonTree)adaptor.nil(); 13907 13908 13909 INSTRUCTION_FORMAT35ms_METHOD459=(Token)match(input,INSTRUCTION_FORMAT35ms_METHOD,FOLLOW_INSTRUCTION_FORMAT35ms_METHOD_in_insn_format35ms_method5554); 13910 INSTRUCTION_FORMAT35ms_METHOD459_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT35ms_METHOD459); 13911 adaptor.addChild(root_0, INSTRUCTION_FORMAT35ms_METHOD459_tree); 13912 13913 OPEN_BRACE460=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format35ms_method5556); 13914 OPEN_BRACE460_tree = (CommonTree)adaptor.create(OPEN_BRACE460); 13915 adaptor.addChild(root_0, OPEN_BRACE460_tree); 13916 13917 pushFollow(FOLLOW_register_list_in_insn_format35ms_method5558); 13918 register_list461=register_list(); 13919 state._fsp--; 13920 13921 adaptor.addChild(root_0, register_list461.getTree()); 13922 13923 CLOSE_BRACE462=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format35ms_method5560); 13924 CLOSE_BRACE462_tree = (CommonTree)adaptor.create(CLOSE_BRACE462); 13925 adaptor.addChild(root_0, CLOSE_BRACE462_tree); 13926 13927 COMMA463=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format35ms_method5562); 13928 COMMA463_tree = (CommonTree)adaptor.create(COMMA463); 13929 adaptor.addChild(root_0, COMMA463_tree); 13930 13931 VTABLE_INDEX464=(Token)match(input,VTABLE_INDEX,FOLLOW_VTABLE_INDEX_in_insn_format35ms_method5564); 13932 VTABLE_INDEX464_tree = (CommonTree)adaptor.create(VTABLE_INDEX464); 13933 adaptor.addChild(root_0, VTABLE_INDEX464_tree); 13934 13935 13936 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT35ms_METHOD459!=null?INSTRUCTION_FORMAT35ms_METHOD459.getText():null)); 13937 13938 } 13939 13940 retval.stop = input.LT(-1); 13941 13942 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13943 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13944 13945 } 13946 catch (RecognitionException re) { 13947 reportError(re); 13948 recover(input,re); 13949 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13950 } 13951 finally { 13952 // do for sure before leaving 13953 } 13954 return retval; 13955 } 13956 // $ANTLR end "insn_format35ms_method" 13957 13958 13959 public static class insn_format3rc_method_return extends ParserRuleReturnScope { 13960 CommonTree tree; 13961 @Override getTree()13962 public CommonTree getTree() { return tree; } 13963 }; 13964 13965 13966 // $ANTLR start "insn_format3rc_method" 13967 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1079: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 ) ; insn_format3rc_method()13968 public final smaliParser.insn_format3rc_method_return insn_format3rc_method() throws RecognitionException { 13969 smaliParser.insn_format3rc_method_return retval = new smaliParser.insn_format3rc_method_return(); 13970 retval.start = input.LT(1); 13971 13972 CommonTree root_0 = null; 13973 13974 Token INSTRUCTION_FORMAT3rc_METHOD465=null; 13975 Token OPEN_BRACE466=null; 13976 Token CLOSE_BRACE468=null; 13977 Token COMMA469=null; 13978 ParserRuleReturnScope register_range467 =null; 13979 ParserRuleReturnScope method_reference470 =null; 13980 13981 CommonTree INSTRUCTION_FORMAT3rc_METHOD465_tree=null; 13982 CommonTree OPEN_BRACE466_tree=null; 13983 CommonTree CLOSE_BRACE468_tree=null; 13984 CommonTree COMMA469_tree=null; 13985 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 13986 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT3rc_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT3rc_METHOD"); 13987 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 13988 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 13989 RewriteRuleSubtreeStream stream_method_reference=new RewriteRuleSubtreeStream(adaptor,"rule method_reference"); 13990 RewriteRuleSubtreeStream stream_register_range=new RewriteRuleSubtreeStream(adaptor,"rule register_range"); 13991 13992 try { 13993 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1080: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 ) ) 13994 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1081:5: INSTRUCTION_FORMAT3rc_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA method_reference 13995 { 13996 INSTRUCTION_FORMAT3rc_METHOD465=(Token)match(input,INSTRUCTION_FORMAT3rc_METHOD,FOLLOW_INSTRUCTION_FORMAT3rc_METHOD_in_insn_format3rc_method5585); 13997 stream_INSTRUCTION_FORMAT3rc_METHOD.add(INSTRUCTION_FORMAT3rc_METHOD465); 13998 13999 OPEN_BRACE466=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format3rc_method5587); 14000 stream_OPEN_BRACE.add(OPEN_BRACE466); 14001 14002 pushFollow(FOLLOW_register_range_in_insn_format3rc_method5589); 14003 register_range467=register_range(); 14004 state._fsp--; 14005 14006 stream_register_range.add(register_range467.getTree()); 14007 CLOSE_BRACE468=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format3rc_method5591); 14008 stream_CLOSE_BRACE.add(CLOSE_BRACE468); 14009 14010 COMMA469=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format3rc_method5593); 14011 stream_COMMA.add(COMMA469); 14012 14013 pushFollow(FOLLOW_method_reference_in_insn_format3rc_method5595); 14014 method_reference470=method_reference(); 14015 state._fsp--; 14016 14017 stream_method_reference.add(method_reference470.getTree()); 14018 // AST REWRITE 14019 // elements: INSTRUCTION_FORMAT3rc_METHOD, method_reference, register_range 14020 // token labels: 14021 // rule labels: retval 14022 // token list labels: 14023 // rule list labels: 14024 // wildcard labels: 14025 retval.tree = root_0; 14026 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 14027 14028 root_0 = (CommonTree)adaptor.nil(); 14029 // 1082:5: -> ^( I_STATEMENT_FORMAT3rc_METHOD[$start, \"I_STATEMENT_FORMAT3rc_METHOD\"] INSTRUCTION_FORMAT3rc_METHOD register_range method_reference ) 14030 { 14031 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1082:8: ^( I_STATEMENT_FORMAT3rc_METHOD[$start, \"I_STATEMENT_FORMAT3rc_METHOD\"] INSTRUCTION_FORMAT3rc_METHOD register_range method_reference ) 14032 { 14033 CommonTree root_1 = (CommonTree)adaptor.nil(); 14034 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT3rc_METHOD, (retval.start), "I_STATEMENT_FORMAT3rc_METHOD"), root_1); 14035 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT3rc_METHOD.nextNode()); 14036 adaptor.addChild(root_1, stream_register_range.nextTree()); 14037 adaptor.addChild(root_1, stream_method_reference.nextTree()); 14038 adaptor.addChild(root_0, root_1); 14039 } 14040 14041 } 14042 14043 14044 retval.tree = root_0; 14045 14046 } 14047 14048 retval.stop = input.LT(-1); 14049 14050 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 14051 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 14052 14053 } 14054 catch (RecognitionException re) { 14055 reportError(re); 14056 recover(input,re); 14057 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 14058 } 14059 finally { 14060 // do for sure before leaving 14061 } 14062 return retval; 14063 } 14064 // $ANTLR end "insn_format3rc_method" 14065 14066 14067 public static class insn_format3rc_method_odex_return extends ParserRuleReturnScope { 14068 CommonTree tree; 14069 @Override getTree()14070 public CommonTree getTree() { return tree; } 14071 }; 14072 14073 14074 // $ANTLR start "insn_format3rc_method_odex" 14075 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1084:1: insn_format3rc_method_odex : INSTRUCTION_FORMAT3rc_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference ; insn_format3rc_method_odex()14076 public final smaliParser.insn_format3rc_method_odex_return insn_format3rc_method_odex() throws RecognitionException { 14077 smaliParser.insn_format3rc_method_odex_return retval = new smaliParser.insn_format3rc_method_odex_return(); 14078 retval.start = input.LT(1); 14079 14080 CommonTree root_0 = null; 14081 14082 Token INSTRUCTION_FORMAT3rc_METHOD_ODEX471=null; 14083 Token OPEN_BRACE472=null; 14084 Token CLOSE_BRACE474=null; 14085 Token COMMA475=null; 14086 ParserRuleReturnScope register_list473 =null; 14087 ParserRuleReturnScope method_reference476 =null; 14088 14089 CommonTree INSTRUCTION_FORMAT3rc_METHOD_ODEX471_tree=null; 14090 CommonTree OPEN_BRACE472_tree=null; 14091 CommonTree CLOSE_BRACE474_tree=null; 14092 CommonTree COMMA475_tree=null; 14093 14094 try { 14095 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1085:3: ( INSTRUCTION_FORMAT3rc_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference ) 14096 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1086:5: INSTRUCTION_FORMAT3rc_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference 14097 { 14098 root_0 = (CommonTree)adaptor.nil(); 14099 14100 14101 INSTRUCTION_FORMAT3rc_METHOD_ODEX471=(Token)match(input,INSTRUCTION_FORMAT3rc_METHOD_ODEX,FOLLOW_INSTRUCTION_FORMAT3rc_METHOD_ODEX_in_insn_format3rc_method_odex5627); 14102 INSTRUCTION_FORMAT3rc_METHOD_ODEX471_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT3rc_METHOD_ODEX471); 14103 adaptor.addChild(root_0, INSTRUCTION_FORMAT3rc_METHOD_ODEX471_tree); 14104 14105 OPEN_BRACE472=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format3rc_method_odex5629); 14106 OPEN_BRACE472_tree = (CommonTree)adaptor.create(OPEN_BRACE472); 14107 adaptor.addChild(root_0, OPEN_BRACE472_tree); 14108 14109 pushFollow(FOLLOW_register_list_in_insn_format3rc_method_odex5631); 14110 register_list473=register_list(); 14111 state._fsp--; 14112 14113 adaptor.addChild(root_0, register_list473.getTree()); 14114 14115 CLOSE_BRACE474=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format3rc_method_odex5633); 14116 CLOSE_BRACE474_tree = (CommonTree)adaptor.create(CLOSE_BRACE474); 14117 adaptor.addChild(root_0, CLOSE_BRACE474_tree); 14118 14119 COMMA475=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format3rc_method_odex5635); 14120 COMMA475_tree = (CommonTree)adaptor.create(COMMA475); 14121 adaptor.addChild(root_0, COMMA475_tree); 14122 14123 pushFollow(FOLLOW_method_reference_in_insn_format3rc_method_odex5637); 14124 method_reference476=method_reference(); 14125 state._fsp--; 14126 14127 adaptor.addChild(root_0, method_reference476.getTree()); 14128 14129 14130 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT3rc_METHOD_ODEX471!=null?INSTRUCTION_FORMAT3rc_METHOD_ODEX471.getText():null)); 14131 14132 } 14133 14134 retval.stop = input.LT(-1); 14135 14136 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 14137 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 14138 14139 } 14140 catch (RecognitionException re) { 14141 reportError(re); 14142 recover(input,re); 14143 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 14144 } 14145 finally { 14146 // do for sure before leaving 14147 } 14148 return retval; 14149 } 14150 // $ANTLR end "insn_format3rc_method_odex" 14151 14152 14153 public static class insn_format3rc_type_return extends ParserRuleReturnScope { 14154 CommonTree tree; 14155 @Override getTree()14156 public CommonTree getTree() { return tree; } 14157 }; 14158 14159 14160 // $ANTLR start "insn_format3rc_type" 14161 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1091: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 ) ; insn_format3rc_type()14162 public final smaliParser.insn_format3rc_type_return insn_format3rc_type() throws RecognitionException { 14163 smaliParser.insn_format3rc_type_return retval = new smaliParser.insn_format3rc_type_return(); 14164 retval.start = input.LT(1); 14165 14166 CommonTree root_0 = null; 14167 14168 Token INSTRUCTION_FORMAT3rc_TYPE477=null; 14169 Token OPEN_BRACE478=null; 14170 Token CLOSE_BRACE480=null; 14171 Token COMMA481=null; 14172 ParserRuleReturnScope register_range479 =null; 14173 ParserRuleReturnScope nonvoid_type_descriptor482 =null; 14174 14175 CommonTree INSTRUCTION_FORMAT3rc_TYPE477_tree=null; 14176 CommonTree OPEN_BRACE478_tree=null; 14177 CommonTree CLOSE_BRACE480_tree=null; 14178 CommonTree COMMA481_tree=null; 14179 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 14180 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT3rc_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT3rc_TYPE"); 14181 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 14182 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 14183 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 14184 RewriteRuleSubtreeStream stream_register_range=new RewriteRuleSubtreeStream(adaptor,"rule register_range"); 14185 14186 try { 14187 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1092: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 ) ) 14188 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1093:5: INSTRUCTION_FORMAT3rc_TYPE OPEN_BRACE register_range CLOSE_BRACE COMMA nonvoid_type_descriptor 14189 { 14190 INSTRUCTION_FORMAT3rc_TYPE477=(Token)match(input,INSTRUCTION_FORMAT3rc_TYPE,FOLLOW_INSTRUCTION_FORMAT3rc_TYPE_in_insn_format3rc_type5658); 14191 stream_INSTRUCTION_FORMAT3rc_TYPE.add(INSTRUCTION_FORMAT3rc_TYPE477); 14192 14193 OPEN_BRACE478=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format3rc_type5660); 14194 stream_OPEN_BRACE.add(OPEN_BRACE478); 14195 14196 pushFollow(FOLLOW_register_range_in_insn_format3rc_type5662); 14197 register_range479=register_range(); 14198 state._fsp--; 14199 14200 stream_register_range.add(register_range479.getTree()); 14201 CLOSE_BRACE480=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format3rc_type5664); 14202 stream_CLOSE_BRACE.add(CLOSE_BRACE480); 14203 14204 COMMA481=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format3rc_type5666); 14205 stream_COMMA.add(COMMA481); 14206 14207 pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format3rc_type5668); 14208 nonvoid_type_descriptor482=nonvoid_type_descriptor(); 14209 state._fsp--; 14210 14211 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor482.getTree()); 14212 // AST REWRITE 14213 // elements: INSTRUCTION_FORMAT3rc_TYPE, nonvoid_type_descriptor, register_range 14214 // token labels: 14215 // rule labels: retval 14216 // token list labels: 14217 // rule list labels: 14218 // wildcard labels: 14219 retval.tree = root_0; 14220 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 14221 14222 root_0 = (CommonTree)adaptor.nil(); 14223 // 1094:5: -> ^( I_STATEMENT_FORMAT3rc_TYPE[$start, \"I_STATEMENT_FORMAT3rc_TYPE\"] INSTRUCTION_FORMAT3rc_TYPE register_range nonvoid_type_descriptor ) 14224 { 14225 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1094:8: ^( I_STATEMENT_FORMAT3rc_TYPE[$start, \"I_STATEMENT_FORMAT3rc_TYPE\"] INSTRUCTION_FORMAT3rc_TYPE register_range nonvoid_type_descriptor ) 14226 { 14227 CommonTree root_1 = (CommonTree)adaptor.nil(); 14228 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT3rc_TYPE, (retval.start), "I_STATEMENT_FORMAT3rc_TYPE"), root_1); 14229 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT3rc_TYPE.nextNode()); 14230 adaptor.addChild(root_1, stream_register_range.nextTree()); 14231 adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree()); 14232 adaptor.addChild(root_0, root_1); 14233 } 14234 14235 } 14236 14237 14238 retval.tree = root_0; 14239 14240 } 14241 14242 retval.stop = input.LT(-1); 14243 14244 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 14245 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 14246 14247 } 14248 catch (RecognitionException re) { 14249 reportError(re); 14250 recover(input,re); 14251 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 14252 } 14253 finally { 14254 // do for sure before leaving 14255 } 14256 return retval; 14257 } 14258 // $ANTLR end "insn_format3rc_type" 14259 14260 14261 public static class insn_format3rmi_method_return extends ParserRuleReturnScope { 14262 CommonTree tree; 14263 @Override getTree()14264 public CommonTree getTree() { return tree; } 14265 }; 14266 14267 14268 // $ANTLR start "insn_format3rmi_method" 14269 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1096:1: insn_format3rmi_method : INSTRUCTION_FORMAT3rmi_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA INLINE_INDEX ; insn_format3rmi_method()14270 public final smaliParser.insn_format3rmi_method_return insn_format3rmi_method() throws RecognitionException { 14271 smaliParser.insn_format3rmi_method_return retval = new smaliParser.insn_format3rmi_method_return(); 14272 retval.start = input.LT(1); 14273 14274 CommonTree root_0 = null; 14275 14276 Token INSTRUCTION_FORMAT3rmi_METHOD483=null; 14277 Token OPEN_BRACE484=null; 14278 Token CLOSE_BRACE486=null; 14279 Token COMMA487=null; 14280 Token INLINE_INDEX488=null; 14281 ParserRuleReturnScope register_range485 =null; 14282 14283 CommonTree INSTRUCTION_FORMAT3rmi_METHOD483_tree=null; 14284 CommonTree OPEN_BRACE484_tree=null; 14285 CommonTree CLOSE_BRACE486_tree=null; 14286 CommonTree COMMA487_tree=null; 14287 CommonTree INLINE_INDEX488_tree=null; 14288 14289 try { 14290 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1097:3: ( INSTRUCTION_FORMAT3rmi_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA INLINE_INDEX ) 14291 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1098:5: INSTRUCTION_FORMAT3rmi_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA INLINE_INDEX 14292 { 14293 root_0 = (CommonTree)adaptor.nil(); 14294 14295 14296 INSTRUCTION_FORMAT3rmi_METHOD483=(Token)match(input,INSTRUCTION_FORMAT3rmi_METHOD,FOLLOW_INSTRUCTION_FORMAT3rmi_METHOD_in_insn_format3rmi_method5700); 14297 INSTRUCTION_FORMAT3rmi_METHOD483_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT3rmi_METHOD483); 14298 adaptor.addChild(root_0, INSTRUCTION_FORMAT3rmi_METHOD483_tree); 14299 14300 OPEN_BRACE484=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format3rmi_method5702); 14301 OPEN_BRACE484_tree = (CommonTree)adaptor.create(OPEN_BRACE484); 14302 adaptor.addChild(root_0, OPEN_BRACE484_tree); 14303 14304 pushFollow(FOLLOW_register_range_in_insn_format3rmi_method5704); 14305 register_range485=register_range(); 14306 state._fsp--; 14307 14308 adaptor.addChild(root_0, register_range485.getTree()); 14309 14310 CLOSE_BRACE486=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format3rmi_method5706); 14311 CLOSE_BRACE486_tree = (CommonTree)adaptor.create(CLOSE_BRACE486); 14312 adaptor.addChild(root_0, CLOSE_BRACE486_tree); 14313 14314 COMMA487=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format3rmi_method5708); 14315 COMMA487_tree = (CommonTree)adaptor.create(COMMA487); 14316 adaptor.addChild(root_0, COMMA487_tree); 14317 14318 INLINE_INDEX488=(Token)match(input,INLINE_INDEX,FOLLOW_INLINE_INDEX_in_insn_format3rmi_method5710); 14319 INLINE_INDEX488_tree = (CommonTree)adaptor.create(INLINE_INDEX488); 14320 adaptor.addChild(root_0, INLINE_INDEX488_tree); 14321 14322 14323 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT3rmi_METHOD483!=null?INSTRUCTION_FORMAT3rmi_METHOD483.getText():null)); 14324 14325 } 14326 14327 retval.stop = input.LT(-1); 14328 14329 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 14330 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 14331 14332 } 14333 catch (RecognitionException re) { 14334 reportError(re); 14335 recover(input,re); 14336 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 14337 } 14338 finally { 14339 // do for sure before leaving 14340 } 14341 return retval; 14342 } 14343 // $ANTLR end "insn_format3rmi_method" 14344 14345 14346 public static class insn_format3rms_method_return extends ParserRuleReturnScope { 14347 CommonTree tree; 14348 @Override getTree()14349 public CommonTree getTree() { return tree; } 14350 }; 14351 14352 14353 // $ANTLR start "insn_format3rms_method" 14354 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1103:1: insn_format3rms_method : INSTRUCTION_FORMAT3rms_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA VTABLE_INDEX ; insn_format3rms_method()14355 public final smaliParser.insn_format3rms_method_return insn_format3rms_method() throws RecognitionException { 14356 smaliParser.insn_format3rms_method_return retval = new smaliParser.insn_format3rms_method_return(); 14357 retval.start = input.LT(1); 14358 14359 CommonTree root_0 = null; 14360 14361 Token INSTRUCTION_FORMAT3rms_METHOD489=null; 14362 Token OPEN_BRACE490=null; 14363 Token CLOSE_BRACE492=null; 14364 Token COMMA493=null; 14365 Token VTABLE_INDEX494=null; 14366 ParserRuleReturnScope register_range491 =null; 14367 14368 CommonTree INSTRUCTION_FORMAT3rms_METHOD489_tree=null; 14369 CommonTree OPEN_BRACE490_tree=null; 14370 CommonTree CLOSE_BRACE492_tree=null; 14371 CommonTree COMMA493_tree=null; 14372 CommonTree VTABLE_INDEX494_tree=null; 14373 14374 try { 14375 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1104:3: ( INSTRUCTION_FORMAT3rms_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA VTABLE_INDEX ) 14376 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1105:5: INSTRUCTION_FORMAT3rms_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA VTABLE_INDEX 14377 { 14378 root_0 = (CommonTree)adaptor.nil(); 14379 14380 14381 INSTRUCTION_FORMAT3rms_METHOD489=(Token)match(input,INSTRUCTION_FORMAT3rms_METHOD,FOLLOW_INSTRUCTION_FORMAT3rms_METHOD_in_insn_format3rms_method5731); 14382 INSTRUCTION_FORMAT3rms_METHOD489_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT3rms_METHOD489); 14383 adaptor.addChild(root_0, INSTRUCTION_FORMAT3rms_METHOD489_tree); 14384 14385 OPEN_BRACE490=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format3rms_method5733); 14386 OPEN_BRACE490_tree = (CommonTree)adaptor.create(OPEN_BRACE490); 14387 adaptor.addChild(root_0, OPEN_BRACE490_tree); 14388 14389 pushFollow(FOLLOW_register_range_in_insn_format3rms_method5735); 14390 register_range491=register_range(); 14391 state._fsp--; 14392 14393 adaptor.addChild(root_0, register_range491.getTree()); 14394 14395 CLOSE_BRACE492=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format3rms_method5737); 14396 CLOSE_BRACE492_tree = (CommonTree)adaptor.create(CLOSE_BRACE492); 14397 adaptor.addChild(root_0, CLOSE_BRACE492_tree); 14398 14399 COMMA493=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format3rms_method5739); 14400 COMMA493_tree = (CommonTree)adaptor.create(COMMA493); 14401 adaptor.addChild(root_0, COMMA493_tree); 14402 14403 VTABLE_INDEX494=(Token)match(input,VTABLE_INDEX,FOLLOW_VTABLE_INDEX_in_insn_format3rms_method5741); 14404 VTABLE_INDEX494_tree = (CommonTree)adaptor.create(VTABLE_INDEX494); 14405 adaptor.addChild(root_0, VTABLE_INDEX494_tree); 14406 14407 14408 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT3rms_METHOD489!=null?INSTRUCTION_FORMAT3rms_METHOD489.getText():null)); 14409 14410 } 14411 14412 retval.stop = input.LT(-1); 14413 14414 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 14415 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 14416 14417 } 14418 catch (RecognitionException re) { 14419 reportError(re); 14420 recover(input,re); 14421 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 14422 } 14423 finally { 14424 // do for sure before leaving 14425 } 14426 return retval; 14427 } 14428 // $ANTLR end "insn_format3rms_method" 14429 14430 14431 public static class insn_format51l_return extends ParserRuleReturnScope { 14432 CommonTree tree; 14433 @Override getTree()14434 public CommonTree getTree() { return tree; } 14435 }; 14436 14437 14438 // $ANTLR start "insn_format51l" 14439 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1110:1: insn_format51l : INSTRUCTION_FORMAT51l REGISTER COMMA fixed_literal -> ^( I_STATEMENT_FORMAT51l[$start, \"I_STATEMENT_FORMAT51l\"] INSTRUCTION_FORMAT51l REGISTER fixed_literal ) ; insn_format51l()14440 public final smaliParser.insn_format51l_return insn_format51l() throws RecognitionException { 14441 smaliParser.insn_format51l_return retval = new smaliParser.insn_format51l_return(); 14442 retval.start = input.LT(1); 14443 14444 CommonTree root_0 = null; 14445 14446 Token INSTRUCTION_FORMAT51l495=null; 14447 Token REGISTER496=null; 14448 Token COMMA497=null; 14449 ParserRuleReturnScope fixed_literal498 =null; 14450 14451 CommonTree INSTRUCTION_FORMAT51l495_tree=null; 14452 CommonTree REGISTER496_tree=null; 14453 CommonTree COMMA497_tree=null; 14454 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 14455 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 14456 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT51l=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT51l"); 14457 RewriteRuleSubtreeStream stream_fixed_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_literal"); 14458 14459 try { 14460 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1111:3: ( INSTRUCTION_FORMAT51l REGISTER COMMA fixed_literal -> ^( I_STATEMENT_FORMAT51l[$start, \"I_STATEMENT_FORMAT51l\"] INSTRUCTION_FORMAT51l REGISTER fixed_literal ) ) 14461 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1112:5: INSTRUCTION_FORMAT51l REGISTER COMMA fixed_literal 14462 { 14463 INSTRUCTION_FORMAT51l495=(Token)match(input,INSTRUCTION_FORMAT51l,FOLLOW_INSTRUCTION_FORMAT51l_in_insn_format51l5762); 14464 stream_INSTRUCTION_FORMAT51l.add(INSTRUCTION_FORMAT51l495); 14465 14466 REGISTER496=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format51l5764); 14467 stream_REGISTER.add(REGISTER496); 14468 14469 COMMA497=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format51l5766); 14470 stream_COMMA.add(COMMA497); 14471 14472 pushFollow(FOLLOW_fixed_literal_in_insn_format51l5768); 14473 fixed_literal498=fixed_literal(); 14474 state._fsp--; 14475 14476 stream_fixed_literal.add(fixed_literal498.getTree()); 14477 // AST REWRITE 14478 // elements: REGISTER, fixed_literal, INSTRUCTION_FORMAT51l 14479 // token labels: 14480 // rule labels: retval 14481 // token list labels: 14482 // rule list labels: 14483 // wildcard labels: 14484 retval.tree = root_0; 14485 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 14486 14487 root_0 = (CommonTree)adaptor.nil(); 14488 // 1113:5: -> ^( I_STATEMENT_FORMAT51l[$start, \"I_STATEMENT_FORMAT51l\"] INSTRUCTION_FORMAT51l REGISTER fixed_literal ) 14489 { 14490 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1113:8: ^( I_STATEMENT_FORMAT51l[$start, \"I_STATEMENT_FORMAT51l\"] INSTRUCTION_FORMAT51l REGISTER fixed_literal ) 14491 { 14492 CommonTree root_1 = (CommonTree)adaptor.nil(); 14493 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT51l, (retval.start), "I_STATEMENT_FORMAT51l"), root_1); 14494 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT51l.nextNode()); 14495 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 14496 adaptor.addChild(root_1, stream_fixed_literal.nextTree()); 14497 adaptor.addChild(root_0, root_1); 14498 } 14499 14500 } 14501 14502 14503 retval.tree = root_0; 14504 14505 } 14506 14507 retval.stop = input.LT(-1); 14508 14509 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 14510 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 14511 14512 } 14513 catch (RecognitionException re) { 14514 reportError(re); 14515 recover(input,re); 14516 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 14517 } 14518 finally { 14519 // do for sure before leaving 14520 } 14521 return retval; 14522 } 14523 // $ANTLR end "insn_format51l" 14524 14525 14526 public static class insn_array_data_directive_return extends ParserRuleReturnScope { 14527 CommonTree tree; 14528 @Override getTree()14529 public CommonTree getTree() { return tree; } 14530 }; 14531 14532 14533 // $ANTLR start "insn_array_data_directive" 14534 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1115: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 )* ) ) ; insn_array_data_directive()14535 public final smaliParser.insn_array_data_directive_return insn_array_data_directive() throws RecognitionException { 14536 smaliParser.insn_array_data_directive_return retval = new smaliParser.insn_array_data_directive_return(); 14537 retval.start = input.LT(1); 14538 14539 CommonTree root_0 = null; 14540 14541 Token ARRAY_DATA_DIRECTIVE499=null; 14542 Token END_ARRAY_DATA_DIRECTIVE502=null; 14543 ParserRuleReturnScope parsed_integer_literal500 =null; 14544 ParserRuleReturnScope fixed_literal501 =null; 14545 14546 CommonTree ARRAY_DATA_DIRECTIVE499_tree=null; 14547 CommonTree END_ARRAY_DATA_DIRECTIVE502_tree=null; 14548 RewriteRuleTokenStream stream_ARRAY_DATA_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token ARRAY_DATA_DIRECTIVE"); 14549 RewriteRuleTokenStream stream_END_ARRAY_DATA_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_ARRAY_DATA_DIRECTIVE"); 14550 RewriteRuleSubtreeStream stream_fixed_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_literal"); 14551 RewriteRuleSubtreeStream stream_parsed_integer_literal=new RewriteRuleSubtreeStream(adaptor,"rule parsed_integer_literal"); 14552 14553 try { 14554 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1116: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 )* ) ) ) 14555 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1116:5: ARRAY_DATA_DIRECTIVE parsed_integer_literal ( fixed_literal )* END_ARRAY_DATA_DIRECTIVE 14556 { 14557 ARRAY_DATA_DIRECTIVE499=(Token)match(input,ARRAY_DATA_DIRECTIVE,FOLLOW_ARRAY_DATA_DIRECTIVE_in_insn_array_data_directive5795); 14558 stream_ARRAY_DATA_DIRECTIVE.add(ARRAY_DATA_DIRECTIVE499); 14559 14560 pushFollow(FOLLOW_parsed_integer_literal_in_insn_array_data_directive5801); 14561 parsed_integer_literal500=parsed_integer_literal(); 14562 state._fsp--; 14563 14564 stream_parsed_integer_literal.add(parsed_integer_literal500.getTree()); 14565 14566 int elementWidth = (parsed_integer_literal500!=null?((smaliParser.parsed_integer_literal_return)parsed_integer_literal500).value:0); 14567 if (elementWidth != 4 && elementWidth != 8 && elementWidth != 1 && elementWidth != 2) { 14568 throw new SemanticException(input, (retval.start), "Invalid element width: %d. Must be 1, 2, 4 or 8", elementWidth); 14569 } 14570 14571 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1124:5: ( fixed_literal )* 14572 loop50: 14573 while (true) { 14574 int alt50=2; 14575 int LA50_0 = input.LA(1); 14576 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) ) { 14577 alt50=1; 14578 } 14579 14580 switch (alt50) { 14581 case 1 : 14582 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1124:5: fixed_literal 14583 { 14584 pushFollow(FOLLOW_fixed_literal_in_insn_array_data_directive5813); 14585 fixed_literal501=fixed_literal(); 14586 state._fsp--; 14587 14588 stream_fixed_literal.add(fixed_literal501.getTree()); 14589 } 14590 break; 14591 14592 default : 14593 break loop50; 14594 } 14595 } 14596 14597 END_ARRAY_DATA_DIRECTIVE502=(Token)match(input,END_ARRAY_DATA_DIRECTIVE,FOLLOW_END_ARRAY_DATA_DIRECTIVE_in_insn_array_data_directive5816); 14598 stream_END_ARRAY_DATA_DIRECTIVE.add(END_ARRAY_DATA_DIRECTIVE502); 14599 14600 // AST REWRITE 14601 // elements: fixed_literal, parsed_integer_literal 14602 // token labels: 14603 // rule labels: retval 14604 // token list labels: 14605 // rule list labels: 14606 // wildcard labels: 14607 retval.tree = root_0; 14608 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 14609 14610 root_0 = (CommonTree)adaptor.nil(); 14611 // 1126:5: -> ^( I_STATEMENT_ARRAY_DATA[$start, \"I_STATEMENT_ARRAY_DATA\"] ^( I_ARRAY_ELEMENT_SIZE parsed_integer_literal ) ^( I_ARRAY_ELEMENTS ( fixed_literal )* ) ) 14612 { 14613 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1126:8: ^( I_STATEMENT_ARRAY_DATA[$start, \"I_STATEMENT_ARRAY_DATA\"] ^( I_ARRAY_ELEMENT_SIZE parsed_integer_literal ) ^( I_ARRAY_ELEMENTS ( fixed_literal )* ) ) 14614 { 14615 CommonTree root_1 = (CommonTree)adaptor.nil(); 14616 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_ARRAY_DATA, (retval.start), "I_STATEMENT_ARRAY_DATA"), root_1); 14617 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1126:67: ^( I_ARRAY_ELEMENT_SIZE parsed_integer_literal ) 14618 { 14619 CommonTree root_2 = (CommonTree)adaptor.nil(); 14620 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ARRAY_ELEMENT_SIZE, "I_ARRAY_ELEMENT_SIZE"), root_2); 14621 adaptor.addChild(root_2, stream_parsed_integer_literal.nextTree()); 14622 adaptor.addChild(root_1, root_2); 14623 } 14624 14625 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1127:8: ^( I_ARRAY_ELEMENTS ( fixed_literal )* ) 14626 { 14627 CommonTree root_2 = (CommonTree)adaptor.nil(); 14628 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ARRAY_ELEMENTS, "I_ARRAY_ELEMENTS"), root_2); 14629 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1127:27: ( fixed_literal )* 14630 while ( stream_fixed_literal.hasNext() ) { 14631 adaptor.addChild(root_2, stream_fixed_literal.nextTree()); 14632 } 14633 stream_fixed_literal.reset(); 14634 14635 adaptor.addChild(root_1, root_2); 14636 } 14637 14638 adaptor.addChild(root_0, root_1); 14639 } 14640 14641 } 14642 14643 14644 retval.tree = root_0; 14645 14646 } 14647 14648 retval.stop = input.LT(-1); 14649 14650 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 14651 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 14652 14653 } 14654 catch (RecognitionException re) { 14655 reportError(re); 14656 recover(input,re); 14657 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 14658 } 14659 finally { 14660 // do for sure before leaving 14661 } 14662 return retval; 14663 } 14664 // $ANTLR end "insn_array_data_directive" 14665 14666 14667 public static class insn_packed_switch_directive_return extends ParserRuleReturnScope { 14668 CommonTree tree; 14669 @Override getTree()14670 public CommonTree getTree() { return tree; } 14671 }; 14672 14673 14674 // $ANTLR start "insn_packed_switch_directive" 14675 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1129: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 )* ) ) ; insn_packed_switch_directive()14676 public final smaliParser.insn_packed_switch_directive_return insn_packed_switch_directive() throws RecognitionException { 14677 smaliParser.insn_packed_switch_directive_return retval = new smaliParser.insn_packed_switch_directive_return(); 14678 retval.start = input.LT(1); 14679 14680 CommonTree root_0 = null; 14681 14682 Token PACKED_SWITCH_DIRECTIVE503=null; 14683 Token END_PACKED_SWITCH_DIRECTIVE506=null; 14684 ParserRuleReturnScope fixed_32bit_literal504 =null; 14685 ParserRuleReturnScope label_ref505 =null; 14686 14687 CommonTree PACKED_SWITCH_DIRECTIVE503_tree=null; 14688 CommonTree END_PACKED_SWITCH_DIRECTIVE506_tree=null; 14689 RewriteRuleTokenStream stream_PACKED_SWITCH_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token PACKED_SWITCH_DIRECTIVE"); 14690 RewriteRuleTokenStream stream_END_PACKED_SWITCH_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_PACKED_SWITCH_DIRECTIVE"); 14691 RewriteRuleSubtreeStream stream_fixed_32bit_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_32bit_literal"); 14692 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 14693 14694 try { 14695 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1130: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 )* ) ) ) 14696 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1130:9: PACKED_SWITCH_DIRECTIVE fixed_32bit_literal ( label_ref )* END_PACKED_SWITCH_DIRECTIVE 14697 { 14698 PACKED_SWITCH_DIRECTIVE503=(Token)match(input,PACKED_SWITCH_DIRECTIVE,FOLLOW_PACKED_SWITCH_DIRECTIVE_in_insn_packed_switch_directive5862); 14699 stream_PACKED_SWITCH_DIRECTIVE.add(PACKED_SWITCH_DIRECTIVE503); 14700 14701 pushFollow(FOLLOW_fixed_32bit_literal_in_insn_packed_switch_directive5868); 14702 fixed_32bit_literal504=fixed_32bit_literal(); 14703 state._fsp--; 14704 14705 stream_fixed_32bit_literal.add(fixed_32bit_literal504.getTree()); 14706 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1132:5: ( label_ref )* 14707 loop51: 14708 while (true) { 14709 int alt51=2; 14710 int LA51_0 = input.LA(1); 14711 if ( (LA51_0==COLON) ) { 14712 alt51=1; 14713 } 14714 14715 switch (alt51) { 14716 case 1 : 14717 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1132:5: label_ref 14718 { 14719 pushFollow(FOLLOW_label_ref_in_insn_packed_switch_directive5874); 14720 label_ref505=label_ref(); 14721 state._fsp--; 14722 14723 stream_label_ref.add(label_ref505.getTree()); 14724 } 14725 break; 14726 14727 default : 14728 break loop51; 14729 } 14730 } 14731 14732 END_PACKED_SWITCH_DIRECTIVE506=(Token)match(input,END_PACKED_SWITCH_DIRECTIVE,FOLLOW_END_PACKED_SWITCH_DIRECTIVE_in_insn_packed_switch_directive5881); 14733 stream_END_PACKED_SWITCH_DIRECTIVE.add(END_PACKED_SWITCH_DIRECTIVE506); 14734 14735 // AST REWRITE 14736 // elements: label_ref, fixed_32bit_literal 14737 // token labels: 14738 // rule labels: retval 14739 // token list labels: 14740 // rule list labels: 14741 // wildcard labels: 14742 retval.tree = root_0; 14743 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 14744 14745 root_0 = (CommonTree)adaptor.nil(); 14746 // 1134: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 )* ) ) 14747 { 14748 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1134: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 )* ) ) 14749 { 14750 CommonTree root_1 = (CommonTree)adaptor.nil(); 14751 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_PACKED_SWITCH, (retval.start), "I_STATEMENT_PACKED_SWITCH"), root_1); 14752 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1135:10: ^( I_PACKED_SWITCH_START_KEY[$start, \"I_PACKED_SWITCH_START_KEY\"] fixed_32bit_literal ) 14753 { 14754 CommonTree root_2 = (CommonTree)adaptor.nil(); 14755 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_PACKED_SWITCH_START_KEY, (retval.start), "I_PACKED_SWITCH_START_KEY"), root_2); 14756 adaptor.addChild(root_2, stream_fixed_32bit_literal.nextTree()); 14757 adaptor.addChild(root_1, root_2); 14758 } 14759 14760 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1136:10: ^( I_PACKED_SWITCH_ELEMENTS[$start, \"I_PACKED_SWITCH_ELEMENTS\"] ( label_ref )* ) 14761 { 14762 CommonTree root_2 = (CommonTree)adaptor.nil(); 14763 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_PACKED_SWITCH_ELEMENTS, (retval.start), "I_PACKED_SWITCH_ELEMENTS"), root_2); 14764 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1137:11: ( label_ref )* 14765 while ( stream_label_ref.hasNext() ) { 14766 adaptor.addChild(root_2, stream_label_ref.nextTree()); 14767 } 14768 stream_label_ref.reset(); 14769 14770 adaptor.addChild(root_1, root_2); 14771 } 14772 14773 adaptor.addChild(root_0, root_1); 14774 } 14775 14776 } 14777 14778 14779 retval.tree = root_0; 14780 14781 } 14782 14783 retval.stop = input.LT(-1); 14784 14785 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 14786 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 14787 14788 } 14789 catch (RecognitionException re) { 14790 reportError(re); 14791 recover(input,re); 14792 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 14793 } 14794 finally { 14795 // do for sure before leaving 14796 } 14797 return retval; 14798 } 14799 // $ANTLR end "insn_packed_switch_directive" 14800 14801 14802 public static class insn_sparse_switch_directive_return extends ParserRuleReturnScope { 14803 CommonTree tree; 14804 @Override getTree()14805 public CommonTree getTree() { return tree; } 14806 }; 14807 14808 14809 // $ANTLR start "insn_sparse_switch_directive" 14810 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1140: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 )* ) ) ; insn_sparse_switch_directive()14811 public final smaliParser.insn_sparse_switch_directive_return insn_sparse_switch_directive() throws RecognitionException { 14812 smaliParser.insn_sparse_switch_directive_return retval = new smaliParser.insn_sparse_switch_directive_return(); 14813 retval.start = input.LT(1); 14814 14815 CommonTree root_0 = null; 14816 14817 Token SPARSE_SWITCH_DIRECTIVE507=null; 14818 Token ARROW509=null; 14819 Token END_SPARSE_SWITCH_DIRECTIVE511=null; 14820 ParserRuleReturnScope fixed_32bit_literal508 =null; 14821 ParserRuleReturnScope label_ref510 =null; 14822 14823 CommonTree SPARSE_SWITCH_DIRECTIVE507_tree=null; 14824 CommonTree ARROW509_tree=null; 14825 CommonTree END_SPARSE_SWITCH_DIRECTIVE511_tree=null; 14826 RewriteRuleTokenStream stream_SPARSE_SWITCH_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token SPARSE_SWITCH_DIRECTIVE"); 14827 RewriteRuleTokenStream stream_ARROW=new RewriteRuleTokenStream(adaptor,"token ARROW"); 14828 RewriteRuleTokenStream stream_END_SPARSE_SWITCH_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_SPARSE_SWITCH_DIRECTIVE"); 14829 RewriteRuleSubtreeStream stream_fixed_32bit_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_32bit_literal"); 14830 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 14831 14832 try { 14833 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1141: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 )* ) ) ) 14834 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1141:7: SPARSE_SWITCH_DIRECTIVE ( fixed_32bit_literal ARROW label_ref )* END_SPARSE_SWITCH_DIRECTIVE 14835 { 14836 SPARSE_SWITCH_DIRECTIVE507=(Token)match(input,SPARSE_SWITCH_DIRECTIVE,FOLLOW_SPARSE_SWITCH_DIRECTIVE_in_insn_sparse_switch_directive5955); 14837 stream_SPARSE_SWITCH_DIRECTIVE.add(SPARSE_SWITCH_DIRECTIVE507); 14838 14839 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1142:5: ( fixed_32bit_literal ARROW label_ref )* 14840 loop52: 14841 while (true) { 14842 int alt52=2; 14843 int LA52_0 = input.LA(1); 14844 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) ) { 14845 alt52=1; 14846 } 14847 14848 switch (alt52) { 14849 case 1 : 14850 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1142:6: fixed_32bit_literal ARROW label_ref 14851 { 14852 pushFollow(FOLLOW_fixed_32bit_literal_in_insn_sparse_switch_directive5962); 14853 fixed_32bit_literal508=fixed_32bit_literal(); 14854 state._fsp--; 14855 14856 stream_fixed_32bit_literal.add(fixed_32bit_literal508.getTree()); 14857 ARROW509=(Token)match(input,ARROW,FOLLOW_ARROW_in_insn_sparse_switch_directive5964); 14858 stream_ARROW.add(ARROW509); 14859 14860 pushFollow(FOLLOW_label_ref_in_insn_sparse_switch_directive5966); 14861 label_ref510=label_ref(); 14862 state._fsp--; 14863 14864 stream_label_ref.add(label_ref510.getTree()); 14865 } 14866 break; 14867 14868 default : 14869 break loop52; 14870 } 14871 } 14872 14873 END_SPARSE_SWITCH_DIRECTIVE511=(Token)match(input,END_SPARSE_SWITCH_DIRECTIVE,FOLLOW_END_SPARSE_SWITCH_DIRECTIVE_in_insn_sparse_switch_directive5974); 14874 stream_END_SPARSE_SWITCH_DIRECTIVE.add(END_SPARSE_SWITCH_DIRECTIVE511); 14875 14876 // AST REWRITE 14877 // elements: fixed_32bit_literal, label_ref 14878 // token labels: 14879 // rule labels: retval 14880 // token list labels: 14881 // rule list labels: 14882 // wildcard labels: 14883 retval.tree = root_0; 14884 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 14885 14886 root_0 = (CommonTree)adaptor.nil(); 14887 // 1144:5: -> ^( I_STATEMENT_SPARSE_SWITCH[$start, \"I_STATEMENT_SPARSE_SWITCH\"] ^( I_SPARSE_SWITCH_ELEMENTS[$start, \"I_SPARSE_SWITCH_ELEMENTS\"] ( fixed_32bit_literal label_ref )* ) ) 14888 { 14889 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1144:8: ^( I_STATEMENT_SPARSE_SWITCH[$start, \"I_STATEMENT_SPARSE_SWITCH\"] ^( I_SPARSE_SWITCH_ELEMENTS[$start, \"I_SPARSE_SWITCH_ELEMENTS\"] ( fixed_32bit_literal label_ref )* ) ) 14890 { 14891 CommonTree root_1 = (CommonTree)adaptor.nil(); 14892 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_SPARSE_SWITCH, (retval.start), "I_STATEMENT_SPARSE_SWITCH"), root_1); 14893 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1145:8: ^( I_SPARSE_SWITCH_ELEMENTS[$start, \"I_SPARSE_SWITCH_ELEMENTS\"] ( fixed_32bit_literal label_ref )* ) 14894 { 14895 CommonTree root_2 = (CommonTree)adaptor.nil(); 14896 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SPARSE_SWITCH_ELEMENTS, (retval.start), "I_SPARSE_SWITCH_ELEMENTS"), root_2); 14897 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr/smaliParser.g:1145:71: ( fixed_32bit_literal label_ref )* 14898 while ( stream_fixed_32bit_literal.hasNext()||stream_label_ref.hasNext() ) { 14899 adaptor.addChild(root_2, stream_fixed_32bit_literal.nextTree()); 14900 adaptor.addChild(root_2, stream_label_ref.nextTree()); 14901 } 14902 stream_fixed_32bit_literal.reset(); 14903 stream_label_ref.reset(); 14904 14905 adaptor.addChild(root_1, root_2); 14906 } 14907 14908 adaptor.addChild(root_0, root_1); 14909 } 14910 14911 } 14912 14913 14914 retval.tree = root_0; 14915 14916 } 14917 14918 retval.stop = input.LT(-1); 14919 14920 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 14921 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 14922 14923 } 14924 catch (RecognitionException re) { 14925 reportError(re); 14926 recover(input,re); 14927 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 14928 } 14929 finally { 14930 // do for sure before leaving 14931 } 14932 return retval; 14933 } 14934 // $ANTLR end "insn_sparse_switch_directive" 14935 14936 // Delegated rules 14937 14938 14939 protected DFA28 dfa28 = new DFA28(this); 14940 protected DFA36 dfa36 = new DFA36(this); 14941 protected DFA38 dfa38 = new DFA38(this); 14942 static final String DFA28_eotS = 14943 "\61\uffff"; 14944 static final String DFA28_eofS = 14945 "\61\uffff"; 14946 static final String DFA28_minS = 14947 "\1\4\12\23\1\u00c0\41\23\2\uffff\1\u00bc\1\23"; 14948 static final String DFA28_maxS = 14949 "\1\u00cd\12\u00b8\1\u00c0\41\u00b8\2\uffff\1\u00c0\1\u00b8"; 14950 static final String DFA28_acceptS = 14951 "\55\uffff\1\1\1\2\2\uffff"; 14952 static final String DFA28_specialS = 14953 "\61\uffff}>"; 14954 static final String[] DFA28_transitionS = { 14955 "\1\2\1\uffff\1\16\3\uffff\1\10\14\uffff\1\7\17\uffff\1\6\2\uffff\1\17"+ 14956 "\1\20\1\21\1\uffff\1\22\1\uffff\1\23\2\uffff\1\24\1\25\1\30\1\31\1\26"+ 14957 "\1\27\3\uffff\1\32\1\uffff\1\33\1\34\1\36\1\35\1\37\1\uffff\1\40\1\41"+ 14958 "\1\uffff\1\42\1\43\3\uffff\1\44\1\45\1\uffff\1\46\1\47\1\50\1\51\1\52"+ 14959 "\5\uffff\1\53\131\uffff\1\54\1\uffff\1\5\1\11\6\uffff\1\13\1\uffff\1"+ 14960 "\4\1\14\1\uffff\1\12\3\uffff\1\1\5\uffff\1\3\1\15", 14961 "\1\55\u00a4\uffff\1\56", 14962 "\1\55\u00a4\uffff\1\56", 14963 "\1\55\u00a4\uffff\1\56", 14964 "\1\55\u00a4\uffff\1\56", 14965 "\1\55\u00a4\uffff\1\56", 14966 "\1\55\u00a4\uffff\1\56", 14967 "\1\55\u00a4\uffff\1\56", 14968 "\1\55\u00a4\uffff\1\56", 14969 "\1\55\u00a4\uffff\1\56", 14970 "\1\55\u00a4\uffff\1\56", 14971 "\1\57", 14972 "\1\55\u00a4\uffff\1\56", 14973 "\1\55\u00a4\uffff\1\56", 14974 "\1\55\u00a4\uffff\1\56", 14975 "\1\55\u00a4\uffff\1\56", 14976 "\1\55\u00a4\uffff\1\56", 14977 "\1\55\u00a4\uffff\1\56", 14978 "\1\55\u00a4\uffff\1\56", 14979 "\1\55\u00a4\uffff\1\56", 14980 "\1\55\u00a4\uffff\1\56", 14981 "\1\55\u00a4\uffff\1\56", 14982 "\1\55\u00a4\uffff\1\56", 14983 "\1\55\u00a4\uffff\1\56", 14984 "\1\55\u00a4\uffff\1\56", 14985 "\1\55\u00a4\uffff\1\56", 14986 "\1\55\u00a4\uffff\1\56", 14987 "\1\55\u00a4\uffff\1\56", 14988 "\1\55\u00a4\uffff\1\56", 14989 "\1\55\u00a4\uffff\1\56", 14990 "\1\55\u00a4\uffff\1\56", 14991 "\1\55\u00a4\uffff\1\56", 14992 "\1\55\u00a4\uffff\1\56", 14993 "\1\55\u00a4\uffff\1\56", 14994 "\1\55\u00a4\uffff\1\56", 14995 "\1\55\u00a4\uffff\1\56", 14996 "\1\55\u00a4\uffff\1\56", 14997 "\1\55\u00a4\uffff\1\56", 14998 "\1\55\u00a4\uffff\1\56", 14999 "\1\55\u00a4\uffff\1\56", 15000 "\1\55\u00a4\uffff\1\56", 15001 "\1\55\u00a4\uffff\1\56", 15002 "\1\55\u00a4\uffff\1\56", 15003 "\1\55\u00a4\uffff\1\56", 15004 "\1\55\u00a4\uffff\1\56", 15005 "", 15006 "", 15007 "\1\60\3\uffff\1\57", 15008 "\1\55\u00a4\uffff\1\56" 15009 }; 15010 15011 static final short[] DFA28_eot = DFA.unpackEncodedString(DFA28_eotS); 15012 static final short[] DFA28_eof = DFA.unpackEncodedString(DFA28_eofS); 15013 static final char[] DFA28_min = DFA.unpackEncodedStringToUnsignedChars(DFA28_minS); 15014 static final char[] DFA28_max = DFA.unpackEncodedStringToUnsignedChars(DFA28_maxS); 15015 static final short[] DFA28_accept = DFA.unpackEncodedString(DFA28_acceptS); 15016 static final short[] DFA28_special = DFA.unpackEncodedString(DFA28_specialS); 15017 static final short[][] DFA28_transition; 15018 15019 static { 15020 int numStates = DFA28_transitionS.length; 15021 DFA28_transition = new short[numStates][]; 15022 for (int i=0; i<numStates; i++) { 15023 DFA28_transition[i] = DFA.unpackEncodedString(DFA28_transitionS[i]); 15024 } 15025 } 15026 15027 protected class DFA28 extends DFA { 15028 DFA28(BaseRecognizer recognizer)15029 public DFA28(BaseRecognizer recognizer) { 15030 this.recognizer = recognizer; 15031 this.decisionNumber = 28; 15032 this.eot = DFA28_eot; 15033 this.eof = DFA28_eof; 15034 this.min = DFA28_min; 15035 this.max = DFA28_max; 15036 this.accept = DFA28_accept; 15037 this.special = DFA28_special; 15038 this.transition = DFA28_transition; 15039 } 15040 @Override getDescription()15041 public String getDescription() { 15042 return "702: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 ) )"; 15043 } 15044 } 15045 15046 static final String DFA36_eotS = 15047 "\65\uffff"; 15048 static final String DFA36_eofS = 15049 "\65\uffff"; 15050 static final String DFA36_minS = 15051 "\1\4\1\5\1\11\12\23\1\u00c0\41\23\1\uffff\1\4\2\uffff\1\u00bc\1\23"; 15052 static final String DFA36_maxS = 15053 "\1\u00cd\1\u00c8\1\11\12\u00b8\1\u00c0\41\u00b8\1\uffff\1\u00cd\2\uffff"+ 15054 "\1\u00c0\1\u00b8"; 15055 static final String DFA36_acceptS = 15056 "\57\uffff\1\1\1\uffff\1\2\1\3\2\uffff"; 15057 static final String DFA36_specialS = 15058 "\65\uffff}>"; 15059 static final String[] DFA36_transitionS = { 15060 "\1\4\1\uffff\1\20\1\uffff\1\2\1\uffff\1\12\4\uffff\1\1\7\uffff\1\11\17"+ 15061 "\uffff\1\10\2\uffff\1\21\1\22\1\23\1\uffff\1\24\1\uffff\1\25\2\uffff"+ 15062 "\1\26\1\27\1\32\1\33\1\30\1\31\3\uffff\1\34\1\uffff\1\35\1\36\1\40\1"+ 15063 "\37\1\41\1\uffff\1\42\1\43\1\uffff\1\44\1\45\3\uffff\1\46\1\47\1\uffff"+ 15064 "\1\50\1\51\1\52\1\53\1\54\5\uffff\1\55\131\uffff\1\56\1\uffff\1\7\1\13"+ 15065 "\6\uffff\1\15\1\uffff\1\6\1\16\1\uffff\1\14\3\uffff\1\3\5\uffff\1\5\1"+ 15066 "\17", 15067 "\1\57\1\uffff\1\57\1\uffff\1\60\2\uffff\2\57\5\uffff\1\57\7\uffff\2"+ 15068 "\57\5\uffff\1\57\7\uffff\60\57\125\uffff\3\57\7\uffff\2\57\6\uffff\1"+ 15069 "\57\1\uffff\2\57\2\uffff\2\57", 15070 "\1\60", 15071 "\1\61\u00a4\uffff\1\62", 15072 "\1\61\u00a4\uffff\1\62", 15073 "\1\61\u00a4\uffff\1\62", 15074 "\1\61\u00a4\uffff\1\62", 15075 "\1\61\u00a4\uffff\1\62", 15076 "\1\61\u00a4\uffff\1\62", 15077 "\1\61\u00a4\uffff\1\62", 15078 "\1\61\u00a4\uffff\1\62", 15079 "\1\61\u00a4\uffff\1\62", 15080 "\1\61\u00a4\uffff\1\62", 15081 "\1\63", 15082 "\1\61\u00a4\uffff\1\62", 15083 "\1\61\u00a4\uffff\1\62", 15084 "\1\61\u00a4\uffff\1\62", 15085 "\1\61\u00a4\uffff\1\62", 15086 "\1\61\u00a4\uffff\1\62", 15087 "\1\61\u00a4\uffff\1\62", 15088 "\1\61\u00a4\uffff\1\62", 15089 "\1\61\u00a4\uffff\1\62", 15090 "\1\61\u00a4\uffff\1\62", 15091 "\1\61\u00a4\uffff\1\62", 15092 "\1\61\u00a4\uffff\1\62", 15093 "\1\61\u00a4\uffff\1\62", 15094 "\1\61\u00a4\uffff\1\62", 15095 "\1\61\u00a4\uffff\1\62", 15096 "\1\61\u00a4\uffff\1\62", 15097 "\1\61\u00a4\uffff\1\62", 15098 "\1\61\u00a4\uffff\1\62", 15099 "\1\61\u00a4\uffff\1\62", 15100 "\1\61\u00a4\uffff\1\62", 15101 "\1\61\u00a4\uffff\1\62", 15102 "\1\61\u00a4\uffff\1\62", 15103 "\1\61\u00a4\uffff\1\62", 15104 "\1\61\u00a4\uffff\1\62", 15105 "\1\61\u00a4\uffff\1\62", 15106 "\1\61\u00a4\uffff\1\62", 15107 "\1\61\u00a4\uffff\1\62", 15108 "\1\61\u00a4\uffff\1\62", 15109 "\1\61\u00a4\uffff\1\62", 15110 "\1\61\u00a4\uffff\1\62", 15111 "\1\61\u00a4\uffff\1\62", 15112 "\1\61\u00a4\uffff\1\62", 15113 "\1\61\u00a4\uffff\1\62", 15114 "\1\61\u00a4\uffff\1\62", 15115 "", 15116 "\1\4\1\uffff\1\20\3\uffff\1\12\14\uffff\1\11\17\uffff\1\10\2\uffff\1"+ 15117 "\21\1\22\1\23\1\uffff\1\24\1\uffff\1\25\2\uffff\1\26\1\27\1\32\1\33\1"+ 15118 "\30\1\31\3\uffff\1\34\1\uffff\1\35\1\36\1\40\1\37\1\41\1\uffff\1\42\1"+ 15119 "\43\1\uffff\1\44\1\45\3\uffff\1\46\1\47\1\uffff\1\50\1\51\1\52\1\53\1"+ 15120 "\54\5\uffff\1\55\131\uffff\1\56\1\uffff\1\7\1\13\6\uffff\1\15\1\uffff"+ 15121 "\1\6\1\16\1\uffff\1\14\3\uffff\1\3\5\uffff\1\5\1\17", 15122 "", 15123 "", 15124 "\1\64\3\uffff\1\63", 15125 "\1\61\u00a4\uffff\1\62" 15126 }; 15127 15128 static final short[] DFA36_eot = DFA.unpackEncodedString(DFA36_eotS); 15129 static final short[] DFA36_eof = DFA.unpackEncodedString(DFA36_eofS); 15130 static final char[] DFA36_min = DFA.unpackEncodedStringToUnsignedChars(DFA36_minS); 15131 static final char[] DFA36_max = DFA.unpackEncodedStringToUnsignedChars(DFA36_maxS); 15132 static final short[] DFA36_accept = DFA.unpackEncodedString(DFA36_acceptS); 15133 static final short[] DFA36_special = DFA.unpackEncodedString(DFA36_specialS); 15134 static final short[][] DFA36_transition; 15135 15136 static { 15137 int numStates = DFA36_transitionS.length; 15138 DFA36_transition = new short[numStates][]; 15139 for (int i=0; i<numStates; i++) { 15140 DFA36_transition[i] = DFA.unpackEncodedString(DFA36_transitionS[i]); 15141 } 15142 } 15143 15144 protected class DFA36 extends DFA { 15145 DFA36(BaseRecognizer recognizer)15146 public DFA36(BaseRecognizer recognizer) { 15147 this.recognizer = recognizer; 15148 this.decisionNumber = 36; 15149 this.eot = DFA36_eot; 15150 this.eof = DFA36_eof; 15151 this.min = DFA36_min; 15152 this.max = DFA36_max; 15153 this.accept = DFA36_accept; 15154 this.special = DFA36_special; 15155 this.transition = DFA36_transition; 15156 } 15157 @Override getDescription()15158 public String getDescription() { 15159 return "730:1: verification_error_reference : ( CLASS_DESCRIPTOR | field_reference | method_reference );"; 15160 } 15161 } 15162 15163 static final String DFA38_eotS = 15164 "\105\uffff"; 15165 static final String DFA38_eofS = 15166 "\105\uffff"; 15167 static final String DFA38_minS = 15168 "\1\5\102\uffff\1\0\1\uffff"; 15169 static final String DFA38_maxS = 15170 "\1\u00c8\102\uffff\1\0\1\uffff"; 15171 static final String DFA38_acceptS = 15172 "\1\uffff\1\2\102\uffff\1\1"; 15173 static final String DFA38_specialS = 15174 "\103\uffff\1\0\1\uffff}>"; 15175 static final String[] DFA38_transitionS = { 15176 "\1\103\1\uffff\1\1\4\uffff\2\1\5\uffff\1\1\7\uffff\2\1\1\uffff\1\1\3"+ 15177 "\uffff\1\1\7\uffff\60\1\125\uffff\3\1\7\uffff\2\1\6\uffff\1\1\1\uffff"+ 15178 "\2\1\2\uffff\2\1", 15179 "", 15180 "", 15181 "", 15182 "", 15183 "", 15184 "", 15185 "", 15186 "", 15187 "", 15188 "", 15189 "", 15190 "", 15191 "", 15192 "", 15193 "", 15194 "", 15195 "", 15196 "", 15197 "", 15198 "", 15199 "", 15200 "", 15201 "", 15202 "", 15203 "", 15204 "", 15205 "", 15206 "", 15207 "", 15208 "", 15209 "", 15210 "", 15211 "", 15212 "", 15213 "", 15214 "", 15215 "", 15216 "", 15217 "", 15218 "", 15219 "", 15220 "", 15221 "", 15222 "", 15223 "", 15224 "", 15225 "", 15226 "", 15227 "", 15228 "", 15229 "", 15230 "", 15231 "", 15232 "", 15233 "", 15234 "", 15235 "", 15236 "", 15237 "", 15238 "", 15239 "", 15240 "", 15241 "", 15242 "", 15243 "", 15244 "", 15245 "\1\uffff", 15246 "" 15247 }; 15248 15249 static final short[] DFA38_eot = DFA.unpackEncodedString(DFA38_eotS); 15250 static final short[] DFA38_eof = DFA.unpackEncodedString(DFA38_eofS); 15251 static final char[] DFA38_min = DFA.unpackEncodedStringToUnsignedChars(DFA38_minS); 15252 static final char[] DFA38_max = DFA.unpackEncodedStringToUnsignedChars(DFA38_maxS); 15253 static final short[] DFA38_accept = DFA.unpackEncodedString(DFA38_acceptS); 15254 static final short[] DFA38_special = DFA.unpackEncodedString(DFA38_specialS); 15255 static final short[][] DFA38_transition; 15256 15257 static { 15258 int numStates = DFA38_transitionS.length; 15259 DFA38_transition = new short[numStates][]; 15260 for (int i=0; i<numStates; i++) { 15261 DFA38_transition[i] = DFA.unpackEncodedString(DFA38_transitionS[i]); 15262 } 15263 } 15264 15265 protected class DFA38 extends DFA { 15266 DFA38(BaseRecognizer recognizer)15267 public DFA38(BaseRecognizer recognizer) { 15268 this.recognizer = recognizer; 15269 this.decisionNumber = 38; 15270 this.eot = DFA38_eot; 15271 this.eof = DFA38_eof; 15272 this.min = DFA38_min; 15273 this.max = DFA38_max; 15274 this.accept = DFA38_accept; 15275 this.special = DFA38_special; 15276 this.transition = DFA38_transition; 15277 } 15278 @Override getDescription()15279 public String getDescription() { 15280 return "()* loopback of 748:5: ({...}? annotation )*"; 15281 } 15282 @Override specialStateTransition(int s, IntStream _input)15283 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { 15284 TokenStream input = (TokenStream)_input; 15285 int _s = s; 15286 switch ( s ) { 15287 case 0 : 15288 int LA38_67 = input.LA(1); 15289 15290 int index38_67 = input.index(); 15291 input.rewind(); 15292 s = -1; 15293 if ( ((input.LA(1) == ANNOTATION_DIRECTIVE)) ) {s = 68;} 15294 else if ( (true) ) {s = 1;} 15295 15296 input.seek(index38_67); 15297 if ( s>=0 ) return s; 15298 break; 15299 } 15300 NoViableAltException nvae = 15301 new NoViableAltException(getDescription(), 38, _s, input); 15302 error(nvae); 15303 throw nvae; 15304 } 15305 } 15306 15307 public static final BitSet FOLLOW_class_spec_in_smali_file1110 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x0010000000000000L,0x0000000000000880L}); 15308 public static final BitSet FOLLOW_super_spec_in_smali_file1121 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x0010000000000000L,0x0000000000000880L}); 15309 public static final BitSet FOLLOW_implements_spec_in_smali_file1129 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x0010000000000000L,0x0000000000000880L}); 15310 public static final BitSet FOLLOW_source_spec_in_smali_file1138 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x0010000000000000L,0x0000000000000880L}); 15311 public static final BitSet FOLLOW_method_in_smali_file1146 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x0010000000000000L,0x0000000000000880L}); 15312 public static final BitSet FOLLOW_field_in_smali_file1152 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x0010000000000000L,0x0000000000000880L}); 15313 public static final BitSet FOLLOW_annotation_in_smali_file1158 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x0010000000000000L,0x0000000000000880L}); 15314 public static final BitSet FOLLOW_EOF_in_smali_file1169 = new BitSet(new long[]{0x0000000000000002L}); 15315 public static final BitSet FOLLOW_CLASS_DIRECTIVE_in_class_spec1256 = new BitSet(new long[]{0x0000000000008010L}); 15316 public static final BitSet FOLLOW_access_list_in_class_spec1258 = new BitSet(new long[]{0x0000000000008000L}); 15317 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_class_spec1260 = new BitSet(new long[]{0x0000000000000002L}); 15318 public static final BitSet FOLLOW_SUPER_DIRECTIVE_in_super_spec1278 = new BitSet(new long[]{0x0000000000008000L}); 15319 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_super_spec1280 = new BitSet(new long[]{0x0000000000000002L}); 15320 public static final BitSet FOLLOW_IMPLEMENTS_DIRECTIVE_in_implements_spec1299 = new BitSet(new long[]{0x0000000000008000L}); 15321 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_implements_spec1301 = new BitSet(new long[]{0x0000000000000002L}); 15322 public static final BitSet FOLLOW_SOURCE_DIRECTIVE_in_source_spec1320 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000200L}); 15323 public static final BitSet FOLLOW_STRING_LITERAL_in_source_spec1322 = new BitSet(new long[]{0x0000000000000002L}); 15324 public static final BitSet FOLLOW_ACCESS_SPEC_in_access_list1341 = new BitSet(new long[]{0x0000000000000012L}); 15325 public static final BitSet FOLLOW_FIELD_DIRECTIVE_in_field1372 = new BitSet(new long[]{0xD1F95C8000800450L,0x00000000020FB1B7L,0xA068000000000000L,0x0000000000003045L}); 15326 public static final BitSet FOLLOW_access_list_in_field1374 = new BitSet(new long[]{0xD1F95C8000800450L,0x00000000020FB1B7L,0xA068000000000000L,0x0000000000003045L}); 15327 public static final BitSet FOLLOW_member_name_in_field1376 = new BitSet(new long[]{0x0000000000080000L}); 15328 public static final BitSet FOLLOW_COLON_in_field1378 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0000000000000000L,0x0000000000000001L}); 15329 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_field1380 = new BitSet(new long[]{0x0000000804000022L}); 15330 public static final BitSet FOLLOW_EQUAL_in_field1383 = new BitSet(new long[]{0xD1F95CC200C0CD50L,0x00000000020FB1B7L,0xA0EC000000000000L,0x0000000000003665L}); 15331 public static final BitSet FOLLOW_literal_in_field1385 = new BitSet(new long[]{0x0000000004000022L}); 15332 public static final BitSet FOLLOW_annotation_in_field1398 = new BitSet(new long[]{0x0000000004000022L}); 15333 public static final BitSet FOLLOW_END_FIELD_DIRECTIVE_in_field1412 = new BitSet(new long[]{0x0000000000000002L}); 15334 public static final BitSet FOLLOW_METHOD_DIRECTIVE_in_method1523 = new BitSet(new long[]{0xD1F95C8000800450L,0x00000000020FB1B7L,0xA068000000000000L,0x0000000000003045L}); 15335 public static final BitSet FOLLOW_access_list_in_method1525 = new BitSet(new long[]{0xD1F95C8000800450L,0x00000000020FB1B7L,0xA068000000000000L,0x0000000000003045L}); 15336 public static final BitSet FOLLOW_member_name_in_method1527 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0100000000000000L}); 15337 public static final BitSet FOLLOW_method_prototype_in_method1529 = new BitSet(new long[]{0xFFFFFC04180830A0L,0x0000000003FFFFFFL,0x0603800000000000L,0x000000000000019AL}); 15338 public static final BitSet FOLLOW_statements_and_directives_in_method1531 = new BitSet(new long[]{0x0000000010000000L}); 15339 public static final BitSet FOLLOW_END_METHOD_DIRECTIVE_in_method1537 = new BitSet(new long[]{0x0000000000000002L}); 15340 public static final BitSet FOLLOW_ordered_method_item_in_statements_and_directives1582 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x0000000003FFFFFFL,0x0603800000000000L,0x000000000000019AL}); 15341 public static final BitSet FOLLOW_registers_directive_in_statements_and_directives1590 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x0000000003FFFFFFL,0x0603800000000000L,0x000000000000019AL}); 15342 public static final BitSet FOLLOW_catch_directive_in_statements_and_directives1598 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x0000000003FFFFFFL,0x0603800000000000L,0x000000000000019AL}); 15343 public static final BitSet FOLLOW_catchall_directive_in_statements_and_directives1606 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x0000000003FFFFFFL,0x0603800000000000L,0x000000000000019AL}); 15344 public static final BitSet FOLLOW_parameter_directive_in_statements_and_directives1614 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x0000000003FFFFFFL,0x0603800000000000L,0x000000000000019AL}); 15345 public static final BitSet FOLLOW_annotation_in_statements_and_directives1622 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x0000000003FFFFFFL,0x0603800000000000L,0x000000000000019AL}); 15346 public static final BitSet FOLLOW_label_in_ordered_method_item1707 = new BitSet(new long[]{0x0000000000000002L}); 15347 public static final BitSet FOLLOW_instruction_in_ordered_method_item1713 = new BitSet(new long[]{0x0000000000000002L}); 15348 public static final BitSet FOLLOW_debug_directive_in_ordered_method_item1719 = new BitSet(new long[]{0x0000000000000002L}); 15349 public static final BitSet FOLLOW_REGISTERS_DIRECTIVE_in_registers_directive1739 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x8024000000000000L,0x0000000000000020L}); 15350 public static final BitSet FOLLOW_integral_literal_in_registers_directive1743 = new BitSet(new long[]{0x0000000000000002L}); 15351 public static final BitSet FOLLOW_LOCALS_DIRECTIVE_in_registers_directive1763 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x8024000000000000L,0x0000000000000020L}); 15352 public static final BitSet FOLLOW_integral_literal_in_registers_directive1767 = new BitSet(new long[]{0x0000000000000002L}); 15353 public static final BitSet FOLLOW_PARAM_LIST_OR_ID_START_in_param_list_or_id1799 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000001L}); 15354 public static final BitSet FOLLOW_PRIMITIVE_TYPE_in_param_list_or_id1801 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x1000000000000000L,0x0000000000000001L}); 15355 public static final BitSet FOLLOW_PARAM_LIST_OR_ID_END_in_param_list_or_id1804 = new BitSet(new long[]{0x0000000000000002L}); 15356 public static final BitSet FOLLOW_SIMPLE_NAME_in_simple_name1816 = new BitSet(new long[]{0x0000000000000002L}); 15357 public static final BitSet FOLLOW_ACCESS_SPEC_in_simple_name1822 = new BitSet(new long[]{0x0000000000000002L}); 15358 public static final BitSet FOLLOW_VERIFICATION_ERROR_TYPE_in_simple_name1833 = new BitSet(new long[]{0x0000000000000002L}); 15359 public static final BitSet FOLLOW_POSITIVE_INTEGER_LITERAL_in_simple_name1844 = new BitSet(new long[]{0x0000000000000002L}); 15360 public static final BitSet FOLLOW_NEGATIVE_INTEGER_LITERAL_in_simple_name1855 = new BitSet(new long[]{0x0000000000000002L}); 15361 public static final BitSet FOLLOW_FLOAT_LITERAL_OR_ID_in_simple_name1866 = new BitSet(new long[]{0x0000000000000002L}); 15362 public static final BitSet FOLLOW_DOUBLE_LITERAL_OR_ID_in_simple_name1877 = new BitSet(new long[]{0x0000000000000002L}); 15363 public static final BitSet FOLLOW_BOOL_LITERAL_in_simple_name1888 = new BitSet(new long[]{0x0000000000000002L}); 15364 public static final BitSet FOLLOW_NULL_LITERAL_in_simple_name1899 = new BitSet(new long[]{0x0000000000000002L}); 15365 public static final BitSet FOLLOW_REGISTER_in_simple_name1910 = new BitSet(new long[]{0x0000000000000002L}); 15366 public static final BitSet FOLLOW_param_list_or_id_in_simple_name1921 = new BitSet(new long[]{0x0000000000000002L}); 15367 public static final BitSet FOLLOW_PRIMITIVE_TYPE_in_simple_name1931 = new BitSet(new long[]{0x0000000000000002L}); 15368 public static final BitSet FOLLOW_VOID_TYPE_in_simple_name1942 = new BitSet(new long[]{0x0000000000000002L}); 15369 public static final BitSet FOLLOW_ANNOTATION_VISIBILITY_in_simple_name1953 = new BitSet(new long[]{0x0000000000000002L}); 15370 public static final BitSet FOLLOW_INSTRUCTION_FORMAT10t_in_simple_name1964 = new BitSet(new long[]{0x0000000000000002L}); 15371 public static final BitSet FOLLOW_INSTRUCTION_FORMAT10x_in_simple_name1975 = new BitSet(new long[]{0x0000000000000002L}); 15372 public static final BitSet FOLLOW_INSTRUCTION_FORMAT10x_ODEX_in_simple_name1986 = new BitSet(new long[]{0x0000000000000002L}); 15373 public static final BitSet FOLLOW_INSTRUCTION_FORMAT11x_in_simple_name1997 = new BitSet(new long[]{0x0000000000000002L}); 15374 public static final BitSet FOLLOW_INSTRUCTION_FORMAT12x_OR_ID_in_simple_name2008 = new BitSet(new long[]{0x0000000000000002L}); 15375 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_FIELD_in_simple_name2019 = new BitSet(new long[]{0x0000000000000002L}); 15376 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_FIELD_ODEX_in_simple_name2030 = new BitSet(new long[]{0x0000000000000002L}); 15377 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_STRING_in_simple_name2041 = new BitSet(new long[]{0x0000000000000002L}); 15378 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_TYPE_in_simple_name2052 = new BitSet(new long[]{0x0000000000000002L}); 15379 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_LAMBDA_in_simple_name2063 = new BitSet(new long[]{0x0000000000000002L}); 15380 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_METHOD_in_simple_name2074 = new BitSet(new long[]{0x0000000000000002L}); 15381 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21t_in_simple_name2085 = new BitSet(new long[]{0x0000000000000002L}); 15382 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_FIELD_in_simple_name2096 = new BitSet(new long[]{0x0000000000000002L}); 15383 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_FIELD_ODEX_in_simple_name2107 = new BitSet(new long[]{0x0000000000000002L}); 15384 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_TYPE_in_simple_name2118 = new BitSet(new long[]{0x0000000000000002L}); 15385 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_STRING_in_simple_name2129 = new BitSet(new long[]{0x0000000000000002L}); 15386 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22cs_FIELD_in_simple_name2140 = new BitSet(new long[]{0x0000000000000002L}); 15387 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22s_OR_ID_in_simple_name2151 = new BitSet(new long[]{0x0000000000000002L}); 15388 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22t_in_simple_name2162 = new BitSet(new long[]{0x0000000000000002L}); 15389 public static final BitSet FOLLOW_INSTRUCTION_FORMAT23x_in_simple_name2173 = new BitSet(new long[]{0x0000000000000002L}); 15390 public static final BitSet FOLLOW_INSTRUCTION_FORMAT25x_in_simple_name2184 = new BitSet(new long[]{0x0000000000000002L}); 15391 public static final BitSet FOLLOW_INSTRUCTION_FORMAT31i_OR_ID_in_simple_name2195 = new BitSet(new long[]{0x0000000000000002L}); 15392 public static final BitSet FOLLOW_INSTRUCTION_FORMAT31t_in_simple_name2206 = new BitSet(new long[]{0x0000000000000002L}); 15393 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_METHOD_in_simple_name2217 = new BitSet(new long[]{0x0000000000000002L}); 15394 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_METHOD_ODEX_in_simple_name2228 = new BitSet(new long[]{0x0000000000000002L}); 15395 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_TYPE_in_simple_name2239 = new BitSet(new long[]{0x0000000000000002L}); 15396 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35mi_METHOD_in_simple_name2250 = new BitSet(new long[]{0x0000000000000002L}); 15397 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35ms_METHOD_in_simple_name2261 = new BitSet(new long[]{0x0000000000000002L}); 15398 public static final BitSet FOLLOW_INSTRUCTION_FORMAT51l_in_simple_name2272 = new BitSet(new long[]{0x0000000000000002L}); 15399 public static final BitSet FOLLOW_simple_name_in_member_name2287 = new BitSet(new long[]{0x0000000000000002L}); 15400 public static final BitSet FOLLOW_MEMBER_NAME_in_member_name2293 = new BitSet(new long[]{0x0000000000000002L}); 15401 public static final BitSet FOLLOW_OPEN_PAREN_in_method_prototype2308 = new BitSet(new long[]{0x0000000000048100L,0x0000000000000000L,0x6000000000000000L,0x0000000000000001L}); 15402 public static final BitSet FOLLOW_param_list_in_method_prototype2310 = new BitSet(new long[]{0x0000000000040000L}); 15403 public static final BitSet FOLLOW_CLOSE_PAREN_in_method_prototype2312 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0000000000000000L,0x0000000000002001L}); 15404 public static final BitSet FOLLOW_type_descriptor_in_method_prototype2314 = new BitSet(new long[]{0x0000000000000002L}); 15405 public static final BitSet FOLLOW_PARAM_LIST_START_in_param_list2344 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0800000000000000L,0x0000000000000001L}); 15406 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_param_list2346 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0800000000000000L,0x0000000000000001L}); 15407 public static final BitSet FOLLOW_PARAM_LIST_END_in_param_list2349 = new BitSet(new long[]{0x0000000000000002L}); 15408 public static final BitSet FOLLOW_PARAM_LIST_OR_ID_START_in_param_list2360 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x1000000000000000L,0x0000000000000001L}); 15409 public static final BitSet FOLLOW_PRIMITIVE_TYPE_in_param_list2362 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x1000000000000000L,0x0000000000000001L}); 15410 public static final BitSet FOLLOW_PARAM_LIST_OR_ID_END_in_param_list2365 = new BitSet(new long[]{0x0000000000000002L}); 15411 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_param_list2376 = new BitSet(new long[]{0x0000000000008102L,0x0000000000000000L,0x0000000000000000L,0x0000000000000001L}); 15412 public static final BitSet FOLLOW_POSITIVE_INTEGER_LITERAL_in_integer_literal2453 = new BitSet(new long[]{0x0000000000000002L}); 15413 public static final BitSet FOLLOW_NEGATIVE_INTEGER_LITERAL_in_integer_literal2464 = new BitSet(new long[]{0x0000000000000002L}); 15414 public static final BitSet FOLLOW_FLOAT_LITERAL_OR_ID_in_float_literal2479 = new BitSet(new long[]{0x0000000000000002L}); 15415 public static final BitSet FOLLOW_FLOAT_LITERAL_in_float_literal2490 = new BitSet(new long[]{0x0000000000000002L}); 15416 public static final BitSet FOLLOW_DOUBLE_LITERAL_OR_ID_in_double_literal2500 = new BitSet(new long[]{0x0000000000000002L}); 15417 public static final BitSet FOLLOW_DOUBLE_LITERAL_in_double_literal2511 = new BitSet(new long[]{0x0000000000000002L}); 15418 public static final BitSet FOLLOW_LONG_LITERAL_in_literal2521 = new BitSet(new long[]{0x0000000000000002L}); 15419 public static final BitSet FOLLOW_integer_literal_in_literal2527 = new BitSet(new long[]{0x0000000000000002L}); 15420 public static final BitSet FOLLOW_SHORT_LITERAL_in_literal2533 = new BitSet(new long[]{0x0000000000000002L}); 15421 public static final BitSet FOLLOW_BYTE_LITERAL_in_literal2539 = new BitSet(new long[]{0x0000000000000002L}); 15422 public static final BitSet FOLLOW_float_literal_in_literal2545 = new BitSet(new long[]{0x0000000000000002L}); 15423 public static final BitSet FOLLOW_double_literal_in_literal2551 = new BitSet(new long[]{0x0000000000000002L}); 15424 public static final BitSet FOLLOW_CHAR_LITERAL_in_literal2557 = new BitSet(new long[]{0x0000000000000002L}); 15425 public static final BitSet FOLLOW_STRING_LITERAL_in_literal2563 = new BitSet(new long[]{0x0000000000000002L}); 15426 public static final BitSet FOLLOW_BOOL_LITERAL_in_literal2569 = new BitSet(new long[]{0x0000000000000002L}); 15427 public static final BitSet FOLLOW_NULL_LITERAL_in_literal2575 = new BitSet(new long[]{0x0000000000000002L}); 15428 public static final BitSet FOLLOW_array_literal_in_literal2581 = new BitSet(new long[]{0x0000000000000002L}); 15429 public static final BitSet FOLLOW_subannotation_in_literal2587 = new BitSet(new long[]{0x0000000000000002L}); 15430 public static final BitSet FOLLOW_type_field_method_literal_in_literal2593 = new BitSet(new long[]{0x0000000000000002L}); 15431 public static final BitSet FOLLOW_enum_literal_in_literal2599 = new BitSet(new long[]{0x0000000000000002L}); 15432 public static final BitSet FOLLOW_integer_literal_in_parsed_integer_literal2612 = new BitSet(new long[]{0x0000000000000002L}); 15433 public static final BitSet FOLLOW_LONG_LITERAL_in_integral_literal2624 = new BitSet(new long[]{0x0000000000000002L}); 15434 public static final BitSet FOLLOW_integer_literal_in_integral_literal2630 = new BitSet(new long[]{0x0000000000000002L}); 15435 public static final BitSet FOLLOW_SHORT_LITERAL_in_integral_literal2636 = new BitSet(new long[]{0x0000000000000002L}); 15436 public static final BitSet FOLLOW_CHAR_LITERAL_in_integral_literal2642 = new BitSet(new long[]{0x0000000000000002L}); 15437 public static final BitSet FOLLOW_BYTE_LITERAL_in_integral_literal2648 = new BitSet(new long[]{0x0000000000000002L}); 15438 public static final BitSet FOLLOW_LONG_LITERAL_in_fixed_32bit_literal2658 = new BitSet(new long[]{0x0000000000000002L}); 15439 public static final BitSet FOLLOW_integer_literal_in_fixed_32bit_literal2664 = new BitSet(new long[]{0x0000000000000002L}); 15440 public static final BitSet FOLLOW_SHORT_LITERAL_in_fixed_32bit_literal2670 = new BitSet(new long[]{0x0000000000000002L}); 15441 public static final BitSet FOLLOW_BYTE_LITERAL_in_fixed_32bit_literal2676 = new BitSet(new long[]{0x0000000000000002L}); 15442 public static final BitSet FOLLOW_float_literal_in_fixed_32bit_literal2682 = new BitSet(new long[]{0x0000000000000002L}); 15443 public static final BitSet FOLLOW_CHAR_LITERAL_in_fixed_32bit_literal2688 = new BitSet(new long[]{0x0000000000000002L}); 15444 public static final BitSet FOLLOW_BOOL_LITERAL_in_fixed_32bit_literal2694 = new BitSet(new long[]{0x0000000000000002L}); 15445 public static final BitSet FOLLOW_integer_literal_in_fixed_literal2704 = new BitSet(new long[]{0x0000000000000002L}); 15446 public static final BitSet FOLLOW_LONG_LITERAL_in_fixed_literal2710 = new BitSet(new long[]{0x0000000000000002L}); 15447 public static final BitSet FOLLOW_SHORT_LITERAL_in_fixed_literal2716 = new BitSet(new long[]{0x0000000000000002L}); 15448 public static final BitSet FOLLOW_BYTE_LITERAL_in_fixed_literal2722 = new BitSet(new long[]{0x0000000000000002L}); 15449 public static final BitSet FOLLOW_float_literal_in_fixed_literal2728 = new BitSet(new long[]{0x0000000000000002L}); 15450 public static final BitSet FOLLOW_double_literal_in_fixed_literal2734 = new BitSet(new long[]{0x0000000000000002L}); 15451 public static final BitSet FOLLOW_CHAR_LITERAL_in_fixed_literal2740 = new BitSet(new long[]{0x0000000000000002L}); 15452 public static final BitSet FOLLOW_BOOL_LITERAL_in_fixed_literal2746 = new BitSet(new long[]{0x0000000000000002L}); 15453 public static final BitSet FOLLOW_OPEN_BRACE_in_array_literal2756 = new BitSet(new long[]{0xD1F95CC200C2CD50L,0x00000000020FB1B7L,0xA0EC000000000000L,0x0000000000003665L}); 15454 public static final BitSet FOLLOW_literal_in_array_literal2759 = new BitSet(new long[]{0x0000000000120000L}); 15455 public static final BitSet FOLLOW_COMMA_in_array_literal2762 = new BitSet(new long[]{0xD1F95CC200C0CD50L,0x00000000020FB1B7L,0xA0EC000000000000L,0x0000000000003665L}); 15456 public static final BitSet FOLLOW_literal_in_array_literal2764 = new BitSet(new long[]{0x0000000000120000L}); 15457 public static final BitSet FOLLOW_CLOSE_BRACE_in_array_literal2772 = new BitSet(new long[]{0x0000000000000002L}); 15458 public static final BitSet FOLLOW_simple_name_in_annotation_element2796 = new BitSet(new long[]{0x0000000800000000L}); 15459 public static final BitSet FOLLOW_EQUAL_in_annotation_element2798 = new BitSet(new long[]{0xD1F95CC200C0CD50L,0x00000000020FB1B7L,0xA0EC000000000000L,0x0000000000003665L}); 15460 public static final BitSet FOLLOW_literal_in_annotation_element2800 = new BitSet(new long[]{0x0000000000000002L}); 15461 public static final BitSet FOLLOW_ANNOTATION_DIRECTIVE_in_annotation2825 = new BitSet(new long[]{0x0000000000000040L}); 15462 public static final BitSet FOLLOW_ANNOTATION_VISIBILITY_in_annotation2827 = new BitSet(new long[]{0x0000000000008000L}); 15463 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_annotation2829 = new BitSet(new long[]{0xD1F95C8001800450L,0x00000000020FB1B7L,0xA060000000000000L,0x0000000000003045L}); 15464 public static final BitSet FOLLOW_annotation_element_in_annotation2835 = new BitSet(new long[]{0xD1F95C8001800450L,0x00000000020FB1B7L,0xA060000000000000L,0x0000000000003045L}); 15465 public static final BitSet FOLLOW_END_ANNOTATION_DIRECTIVE_in_annotation2838 = new BitSet(new long[]{0x0000000000000002L}); 15466 public static final BitSet FOLLOW_SUBANNOTATION_DIRECTIVE_in_subannotation2871 = new BitSet(new long[]{0x0000000000008000L}); 15467 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_subannotation2873 = new BitSet(new long[]{0xD1F95C8100800450L,0x00000000020FB1B7L,0xA060000000000000L,0x0000000000003045L}); 15468 public static final BitSet FOLLOW_annotation_element_in_subannotation2875 = new BitSet(new long[]{0xD1F95C8100800450L,0x00000000020FB1B7L,0xA060000000000000L,0x0000000000003045L}); 15469 public static final BitSet FOLLOW_END_SUBANNOTATION_DIRECTIVE_in_subannotation2878 = new BitSet(new long[]{0x0000000000000002L}); 15470 public static final BitSet FOLLOW_ENUM_DIRECTIVE_in_enum_literal2904 = new BitSet(new long[]{0x0000000000008100L}); 15471 public static final BitSet FOLLOW_reference_type_descriptor_in_enum_literal2906 = new BitSet(new long[]{0x0000000000000200L}); 15472 public static final BitSet FOLLOW_ARROW_in_enum_literal2908 = new BitSet(new long[]{0xD1F95C8000800450L,0x00000000020FB1B7L,0xA060000000000000L,0x0000000000003045L}); 15473 public static final BitSet FOLLOW_simple_name_in_enum_literal2910 = new BitSet(new long[]{0x0000000000080000L}); 15474 public static final BitSet FOLLOW_COLON_in_enum_literal2912 = new BitSet(new long[]{0x0000000000008100L}); 15475 public static final BitSet FOLLOW_reference_type_descriptor_in_enum_literal2914 = new BitSet(new long[]{0x0000000000000002L}); 15476 public static final BitSet FOLLOW_reference_type_descriptor_in_type_field_method_literal2938 = new BitSet(new long[]{0x0000000000000002L}); 15477 public static final BitSet FOLLOW_reference_type_descriptor_in_type_field_method_literal2947 = new BitSet(new long[]{0x0000000000000200L}); 15478 public static final BitSet FOLLOW_ARROW_in_type_field_method_literal2949 = new BitSet(new long[]{0xD1F95C8000800450L,0x00000000020FB1B7L,0xA068000000000000L,0x0000000000003045L}); 15479 public static final BitSet FOLLOW_member_name_in_type_field_method_literal2961 = new BitSet(new long[]{0x0000000000080000L}); 15480 public static final BitSet FOLLOW_COLON_in_type_field_method_literal2963 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0000000000000000L,0x0000000000000001L}); 15481 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_type_field_method_literal2965 = new BitSet(new long[]{0x0000000000000002L}); 15482 public static final BitSet FOLLOW_member_name_in_type_field_method_literal2988 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0100000000000000L}); 15483 public static final BitSet FOLLOW_method_prototype_in_type_field_method_literal2990 = new BitSet(new long[]{0x0000000000000002L}); 15484 public static final BitSet FOLLOW_PRIMITIVE_TYPE_in_type_field_method_literal3023 = new BitSet(new long[]{0x0000000000000002L}); 15485 public static final BitSet FOLLOW_VOID_TYPE_in_type_field_method_literal3029 = new BitSet(new long[]{0x0000000000000002L}); 15486 public static final BitSet FOLLOW_reference_type_descriptor_in_method_reference3040 = new BitSet(new long[]{0x0000000000000200L}); 15487 public static final BitSet FOLLOW_ARROW_in_method_reference3042 = new BitSet(new long[]{0xD1F95C8000800450L,0x00000000020FB1B7L,0xA068000000000000L,0x0000000000003045L}); 15488 public static final BitSet FOLLOW_member_name_in_method_reference3046 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0100000000000000L}); 15489 public static final BitSet FOLLOW_method_prototype_in_method_reference3048 = new BitSet(new long[]{0x0000000000000002L}); 15490 public static final BitSet FOLLOW_reference_type_descriptor_in_field_reference3070 = new BitSet(new long[]{0x0000000000000200L}); 15491 public static final BitSet FOLLOW_ARROW_in_field_reference3072 = new BitSet(new long[]{0xD1F95C8000800450L,0x00000000020FB1B7L,0xA068000000000000L,0x0000000000003045L}); 15492 public static final BitSet FOLLOW_member_name_in_field_reference3076 = new BitSet(new long[]{0x0000000000080000L}); 15493 public static final BitSet FOLLOW_COLON_in_field_reference3078 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0000000000000000L,0x0000000000000001L}); 15494 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_field_reference3080 = new BitSet(new long[]{0x0000000000000002L}); 15495 public static final BitSet FOLLOW_COLON_in_label3101 = new BitSet(new long[]{0xD1F95C8000800450L,0x00000000020FB1B7L,0xA060000000000000L,0x0000000000003045L}); 15496 public static final BitSet FOLLOW_simple_name_in_label3103 = new BitSet(new long[]{0x0000000000000002L}); 15497 public static final BitSet FOLLOW_COLON_in_label_ref3122 = new BitSet(new long[]{0xD1F95C8000800450L,0x00000000020FB1B7L,0xA060000000000000L,0x0000000000003045L}); 15498 public static final BitSet FOLLOW_simple_name_in_label_ref3124 = new BitSet(new long[]{0x0000000000000002L}); 15499 public static final BitSet FOLLOW_REGISTER_in_register_list3138 = new BitSet(new long[]{0x0000000000100002L}); 15500 public static final BitSet FOLLOW_COMMA_in_register_list3141 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15501 public static final BitSet FOLLOW_REGISTER_in_register_list3143 = new BitSet(new long[]{0x0000000000100002L}); 15502 public static final BitSet FOLLOW_REGISTER_in_register_range3178 = new BitSet(new long[]{0x0000000000200002L}); 15503 public static final BitSet FOLLOW_DOTDOT_in_register_range3181 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15504 public static final BitSet FOLLOW_REGISTER_in_register_range3185 = new BitSet(new long[]{0x0000000000000002L}); 15505 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_verification_error_reference3214 = new BitSet(new long[]{0x0000000000000002L}); 15506 public static final BitSet FOLLOW_field_reference_in_verification_error_reference3218 = new BitSet(new long[]{0x0000000000000002L}); 15507 public static final BitSet FOLLOW_method_reference_in_verification_error_reference3222 = new BitSet(new long[]{0x0000000000000002L}); 15508 public static final BitSet FOLLOW_CATCH_DIRECTIVE_in_catch_directive3232 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0000000000000000L,0x0000000000000001L}); 15509 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_catch_directive3234 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0080000000000000L}); 15510 public static final BitSet FOLLOW_OPEN_BRACE_in_catch_directive3236 = new BitSet(new long[]{0x0000000000080000L}); 15511 public static final BitSet FOLLOW_label_ref_in_catch_directive3240 = new BitSet(new long[]{0x0000000000200000L}); 15512 public static final BitSet FOLLOW_DOTDOT_in_catch_directive3242 = new BitSet(new long[]{0x0000000000080000L}); 15513 public static final BitSet FOLLOW_label_ref_in_catch_directive3246 = new BitSet(new long[]{0x0000000000020000L}); 15514 public static final BitSet FOLLOW_CLOSE_BRACE_in_catch_directive3248 = new BitSet(new long[]{0x0000000000080000L}); 15515 public static final BitSet FOLLOW_label_ref_in_catch_directive3252 = new BitSet(new long[]{0x0000000000000002L}); 15516 public static final BitSet FOLLOW_CATCHALL_DIRECTIVE_in_catchall_directive3284 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0080000000000000L}); 15517 public static final BitSet FOLLOW_OPEN_BRACE_in_catchall_directive3286 = new BitSet(new long[]{0x0000000000080000L}); 15518 public static final BitSet FOLLOW_label_ref_in_catchall_directive3290 = new BitSet(new long[]{0x0000000000200000L}); 15519 public static final BitSet FOLLOW_DOTDOT_in_catchall_directive3292 = new BitSet(new long[]{0x0000000000080000L}); 15520 public static final BitSet FOLLOW_label_ref_in_catchall_directive3296 = new BitSet(new long[]{0x0000000000020000L}); 15521 public static final BitSet FOLLOW_CLOSE_BRACE_in_catchall_directive3298 = new BitSet(new long[]{0x0000000000080000L}); 15522 public static final BitSet FOLLOW_label_ref_in_catchall_directive3302 = new BitSet(new long[]{0x0000000000000002L}); 15523 public static final BitSet FOLLOW_PARAMETER_DIRECTIVE_in_parameter_directive3341 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15524 public static final BitSet FOLLOW_REGISTER_in_parameter_directive3343 = new BitSet(new long[]{0x0000000040100022L}); 15525 public static final BitSet FOLLOW_COMMA_in_parameter_directive3346 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000200L}); 15526 public static final BitSet FOLLOW_STRING_LITERAL_in_parameter_directive3348 = new BitSet(new long[]{0x0000000040000022L}); 15527 public static final BitSet FOLLOW_annotation_in_parameter_directive3359 = new BitSet(new long[]{0x0000000040000022L}); 15528 public static final BitSet FOLLOW_END_PARAMETER_DIRECTIVE_in_parameter_directive3372 = new BitSet(new long[]{0x0000000000000002L}); 15529 public static final BitSet FOLLOW_line_directive_in_debug_directive3445 = new BitSet(new long[]{0x0000000000000002L}); 15530 public static final BitSet FOLLOW_local_directive_in_debug_directive3451 = new BitSet(new long[]{0x0000000000000002L}); 15531 public static final BitSet FOLLOW_end_local_directive_in_debug_directive3457 = new BitSet(new long[]{0x0000000000000002L}); 15532 public static final BitSet FOLLOW_restart_local_directive_in_debug_directive3463 = new BitSet(new long[]{0x0000000000000002L}); 15533 public static final BitSet FOLLOW_prologue_directive_in_debug_directive3469 = new BitSet(new long[]{0x0000000000000002L}); 15534 public static final BitSet FOLLOW_epilogue_directive_in_debug_directive3475 = new BitSet(new long[]{0x0000000000000002L}); 15535 public static final BitSet FOLLOW_source_directive_in_debug_directive3481 = new BitSet(new long[]{0x0000000000000002L}); 15536 public static final BitSet FOLLOW_LINE_DIRECTIVE_in_line_directive3491 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x8024000000000000L,0x0000000000000020L}); 15537 public static final BitSet FOLLOW_integral_literal_in_line_directive3493 = new BitSet(new long[]{0x0000000000000002L}); 15538 public static final BitSet FOLLOW_LOCAL_DIRECTIVE_in_local_directive3516 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15539 public static final BitSet FOLLOW_REGISTER_in_local_directive3518 = new BitSet(new long[]{0x0000000000100002L}); 15540 public static final BitSet FOLLOW_COMMA_in_local_directive3521 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0040000000000000L,0x0000000000000200L}); 15541 public static final BitSet FOLLOW_NULL_LITERAL_in_local_directive3524 = new BitSet(new long[]{0x0000000000080000L}); 15542 public static final BitSet FOLLOW_STRING_LITERAL_in_local_directive3530 = new BitSet(new long[]{0x0000000000080000L}); 15543 public static final BitSet FOLLOW_COLON_in_local_directive3533 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0000000000000000L,0x0000000000002001L}); 15544 public static final BitSet FOLLOW_VOID_TYPE_in_local_directive3536 = new BitSet(new long[]{0x0000000000100002L}); 15545 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_local_directive3540 = new BitSet(new long[]{0x0000000000100002L}); 15546 public static final BitSet FOLLOW_COMMA_in_local_directive3574 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000200L}); 15547 public static final BitSet FOLLOW_STRING_LITERAL_in_local_directive3578 = new BitSet(new long[]{0x0000000000000002L}); 15548 public static final BitSet FOLLOW_END_LOCAL_DIRECTIVE_in_end_local_directive3620 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15549 public static final BitSet FOLLOW_REGISTER_in_end_local_directive3622 = new BitSet(new long[]{0x0000000000000002L}); 15550 public static final BitSet FOLLOW_RESTART_LOCAL_DIRECTIVE_in_restart_local_directive3645 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15551 public static final BitSet FOLLOW_REGISTER_in_restart_local_directive3647 = new BitSet(new long[]{0x0000000000000002L}); 15552 public static final BitSet FOLLOW_PROLOGUE_DIRECTIVE_in_prologue_directive3670 = new BitSet(new long[]{0x0000000000000002L}); 15553 public static final BitSet FOLLOW_EPILOGUE_DIRECTIVE_in_epilogue_directive3691 = new BitSet(new long[]{0x0000000000000002L}); 15554 public static final BitSet FOLLOW_SOURCE_DIRECTIVE_in_source_directive3712 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000000200L}); 15555 public static final BitSet FOLLOW_STRING_LITERAL_in_source_directive3714 = new BitSet(new long[]{0x0000000000000002L}); 15556 public static final BitSet FOLLOW_INSTRUCTION_FORMAT12x_in_instruction_format12x3739 = new BitSet(new long[]{0x0000000000000002L}); 15557 public static final BitSet FOLLOW_INSTRUCTION_FORMAT12x_OR_ID_in_instruction_format12x3745 = new BitSet(new long[]{0x0000000000000002L}); 15558 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22s_in_instruction_format22s3760 = new BitSet(new long[]{0x0000000000000002L}); 15559 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22s_OR_ID_in_instruction_format22s3766 = new BitSet(new long[]{0x0000000000000002L}); 15560 public static final BitSet FOLLOW_INSTRUCTION_FORMAT31i_in_instruction_format31i3781 = new BitSet(new long[]{0x0000000000000002L}); 15561 public static final BitSet FOLLOW_INSTRUCTION_FORMAT31i_OR_ID_in_instruction_format31i3787 = new BitSet(new long[]{0x0000000000000002L}); 15562 public static final BitSet FOLLOW_insn_format10t_in_instruction3804 = new BitSet(new long[]{0x0000000000000002L}); 15563 public static final BitSet FOLLOW_insn_format10x_in_instruction3810 = new BitSet(new long[]{0x0000000000000002L}); 15564 public static final BitSet FOLLOW_insn_format10x_odex_in_instruction3816 = new BitSet(new long[]{0x0000000000000002L}); 15565 public static final BitSet FOLLOW_insn_format11n_in_instruction3822 = new BitSet(new long[]{0x0000000000000002L}); 15566 public static final BitSet FOLLOW_insn_format11x_in_instruction3828 = new BitSet(new long[]{0x0000000000000002L}); 15567 public static final BitSet FOLLOW_insn_format12x_in_instruction3834 = new BitSet(new long[]{0x0000000000000002L}); 15568 public static final BitSet FOLLOW_insn_format20bc_in_instruction3840 = new BitSet(new long[]{0x0000000000000002L}); 15569 public static final BitSet FOLLOW_insn_format20t_in_instruction3846 = new BitSet(new long[]{0x0000000000000002L}); 15570 public static final BitSet FOLLOW_insn_format21c_field_in_instruction3852 = new BitSet(new long[]{0x0000000000000002L}); 15571 public static final BitSet FOLLOW_insn_format21c_field_odex_in_instruction3858 = new BitSet(new long[]{0x0000000000000002L}); 15572 public static final BitSet FOLLOW_insn_format21c_string_in_instruction3864 = new BitSet(new long[]{0x0000000000000002L}); 15573 public static final BitSet FOLLOW_insn_format21c_type_in_instruction3870 = new BitSet(new long[]{0x0000000000000002L}); 15574 public static final BitSet FOLLOW_insn_format21c_lambda_in_instruction3876 = new BitSet(new long[]{0x0000000000000002L}); 15575 public static final BitSet FOLLOW_insn_format21c_method_in_instruction3882 = new BitSet(new long[]{0x0000000000000002L}); 15576 public static final BitSet FOLLOW_insn_format21ih_in_instruction3888 = new BitSet(new long[]{0x0000000000000002L}); 15577 public static final BitSet FOLLOW_insn_format21lh_in_instruction3894 = new BitSet(new long[]{0x0000000000000002L}); 15578 public static final BitSet FOLLOW_insn_format21s_in_instruction3900 = new BitSet(new long[]{0x0000000000000002L}); 15579 public static final BitSet FOLLOW_insn_format21t_in_instruction3906 = new BitSet(new long[]{0x0000000000000002L}); 15580 public static final BitSet FOLLOW_insn_format22b_in_instruction3912 = new BitSet(new long[]{0x0000000000000002L}); 15581 public static final BitSet FOLLOW_insn_format22c_field_in_instruction3918 = new BitSet(new long[]{0x0000000000000002L}); 15582 public static final BitSet FOLLOW_insn_format22c_field_odex_in_instruction3924 = new BitSet(new long[]{0x0000000000000002L}); 15583 public static final BitSet FOLLOW_insn_format22c_type_in_instruction3930 = new BitSet(new long[]{0x0000000000000002L}); 15584 public static final BitSet FOLLOW_insn_format22c_string_in_instruction3936 = new BitSet(new long[]{0x0000000000000002L}); 15585 public static final BitSet FOLLOW_insn_format22cs_field_in_instruction3942 = new BitSet(new long[]{0x0000000000000002L}); 15586 public static final BitSet FOLLOW_insn_format22s_in_instruction3948 = new BitSet(new long[]{0x0000000000000002L}); 15587 public static final BitSet FOLLOW_insn_format22t_in_instruction3954 = new BitSet(new long[]{0x0000000000000002L}); 15588 public static final BitSet FOLLOW_insn_format22x_in_instruction3960 = new BitSet(new long[]{0x0000000000000002L}); 15589 public static final BitSet FOLLOW_insn_format23x_in_instruction3966 = new BitSet(new long[]{0x0000000000000002L}); 15590 public static final BitSet FOLLOW_insn_format25x_in_instruction3972 = new BitSet(new long[]{0x0000000000000002L}); 15591 public static final BitSet FOLLOW_insn_format30t_in_instruction3978 = new BitSet(new long[]{0x0000000000000002L}); 15592 public static final BitSet FOLLOW_insn_format31c_in_instruction3984 = new BitSet(new long[]{0x0000000000000002L}); 15593 public static final BitSet FOLLOW_insn_format31i_in_instruction3990 = new BitSet(new long[]{0x0000000000000002L}); 15594 public static final BitSet FOLLOW_insn_format31t_in_instruction3996 = new BitSet(new long[]{0x0000000000000002L}); 15595 public static final BitSet FOLLOW_insn_format32x_in_instruction4002 = new BitSet(new long[]{0x0000000000000002L}); 15596 public static final BitSet FOLLOW_insn_format35c_method_in_instruction4008 = new BitSet(new long[]{0x0000000000000002L}); 15597 public static final BitSet FOLLOW_insn_format35c_type_in_instruction4014 = new BitSet(new long[]{0x0000000000000002L}); 15598 public static final BitSet FOLLOW_insn_format35c_method_odex_in_instruction4020 = new BitSet(new long[]{0x0000000000000002L}); 15599 public static final BitSet FOLLOW_insn_format35mi_method_in_instruction4026 = new BitSet(new long[]{0x0000000000000002L}); 15600 public static final BitSet FOLLOW_insn_format35ms_method_in_instruction4032 = new BitSet(new long[]{0x0000000000000002L}); 15601 public static final BitSet FOLLOW_insn_format3rc_method_in_instruction4038 = new BitSet(new long[]{0x0000000000000002L}); 15602 public static final BitSet FOLLOW_insn_format3rc_method_odex_in_instruction4044 = new BitSet(new long[]{0x0000000000000002L}); 15603 public static final BitSet FOLLOW_insn_format3rc_type_in_instruction4050 = new BitSet(new long[]{0x0000000000000002L}); 15604 public static final BitSet FOLLOW_insn_format3rmi_method_in_instruction4056 = new BitSet(new long[]{0x0000000000000002L}); 15605 public static final BitSet FOLLOW_insn_format3rms_method_in_instruction4062 = new BitSet(new long[]{0x0000000000000002L}); 15606 public static final BitSet FOLLOW_insn_format51l_in_instruction4068 = new BitSet(new long[]{0x0000000000000002L}); 15607 public static final BitSet FOLLOW_insn_array_data_directive_in_instruction4074 = new BitSet(new long[]{0x0000000000000002L}); 15608 public static final BitSet FOLLOW_insn_packed_switch_directive_in_instruction4080 = new BitSet(new long[]{0x0000000000000002L}); 15609 public static final BitSet FOLLOW_insn_sparse_switch_directive_in_instruction4086 = new BitSet(new long[]{0x0000000000000002L}); 15610 public static final BitSet FOLLOW_INSTRUCTION_FORMAT10t_in_insn_format10t4106 = new BitSet(new long[]{0x0000000000080000L}); 15611 public static final BitSet FOLLOW_label_ref_in_insn_format10t4108 = new BitSet(new long[]{0x0000000000000002L}); 15612 public static final BitSet FOLLOW_INSTRUCTION_FORMAT10x_in_insn_format10x4138 = new BitSet(new long[]{0x0000000000000002L}); 15613 public static final BitSet FOLLOW_INSTRUCTION_FORMAT10x_ODEX_in_insn_format10x_odex4166 = new BitSet(new long[]{0x0000000000000002L}); 15614 public static final BitSet FOLLOW_INSTRUCTION_FORMAT11n_in_insn_format11n4187 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15615 public static final BitSet FOLLOW_REGISTER_in_insn_format11n4189 = new BitSet(new long[]{0x0000000000100000L}); 15616 public static final BitSet FOLLOW_COMMA_in_insn_format11n4191 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x8024000000000000L,0x0000000000000020L}); 15617 public static final BitSet FOLLOW_integral_literal_in_insn_format11n4193 = new BitSet(new long[]{0x0000000000000002L}); 15618 public static final BitSet FOLLOW_INSTRUCTION_FORMAT11x_in_insn_format11x4225 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15619 public static final BitSet FOLLOW_REGISTER_in_insn_format11x4227 = new BitSet(new long[]{0x0000000000000002L}); 15620 public static final BitSet FOLLOW_instruction_format12x_in_insn_format12x4257 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15621 public static final BitSet FOLLOW_REGISTER_in_insn_format12x4259 = new BitSet(new long[]{0x0000000000100000L}); 15622 public static final BitSet FOLLOW_COMMA_in_insn_format12x4261 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15623 public static final BitSet FOLLOW_REGISTER_in_insn_format12x4263 = new BitSet(new long[]{0x0000000000000002L}); 15624 public static final BitSet FOLLOW_INSTRUCTION_FORMAT20bc_in_insn_format20bc4295 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000001000L}); 15625 public static final BitSet FOLLOW_VERIFICATION_ERROR_TYPE_in_insn_format20bc4297 = new BitSet(new long[]{0x0000000000100000L}); 15626 public static final BitSet FOLLOW_COMMA_in_insn_format20bc4299 = new BitSet(new long[]{0xD1F95C8000808550L,0x00000000020FB1B7L,0xA068000000000000L,0x0000000000003045L}); 15627 public static final BitSet FOLLOW_verification_error_reference_in_insn_format20bc4301 = new BitSet(new long[]{0x0000000000000002L}); 15628 public static final BitSet FOLLOW_INSTRUCTION_FORMAT20t_in_insn_format20t4338 = new BitSet(new long[]{0x0000000000080000L}); 15629 public static final BitSet FOLLOW_label_ref_in_insn_format20t4340 = new BitSet(new long[]{0x0000000000000002L}); 15630 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_FIELD_in_insn_format21c_field4370 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15631 public static final BitSet FOLLOW_REGISTER_in_insn_format21c_field4372 = new BitSet(new long[]{0x0000000000100000L}); 15632 public static final BitSet FOLLOW_COMMA_in_insn_format21c_field4374 = new BitSet(new long[]{0xD1F95C8000808550L,0x00000000020FB1B7L,0xA068000000000000L,0x0000000000003045L}); 15633 public static final BitSet FOLLOW_field_reference_in_insn_format21c_field4376 = new BitSet(new long[]{0x0000000000000002L}); 15634 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_FIELD_ODEX_in_insn_format21c_field_odex4408 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15635 public static final BitSet FOLLOW_REGISTER_in_insn_format21c_field_odex4410 = new BitSet(new long[]{0x0000000000100000L}); 15636 public static final BitSet FOLLOW_COMMA_in_insn_format21c_field_odex4412 = new BitSet(new long[]{0xD1F95C8000808550L,0x00000000020FB1B7L,0xA068000000000000L,0x0000000000003045L}); 15637 public static final BitSet FOLLOW_field_reference_in_insn_format21c_field_odex4414 = new BitSet(new long[]{0x0000000000000002L}); 15638 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_STRING_in_insn_format21c_string4452 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15639 public static final BitSet FOLLOW_REGISTER_in_insn_format21c_string4454 = new BitSet(new long[]{0x0000000000100000L}); 15640 public static final BitSet FOLLOW_COMMA_in_insn_format21c_string4456 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000200L}); 15641 public static final BitSet FOLLOW_STRING_LITERAL_in_insn_format21c_string4458 = new BitSet(new long[]{0x0000000000000002L}); 15642 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_TYPE_in_insn_format21c_type4490 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15643 public static final BitSet FOLLOW_REGISTER_in_insn_format21c_type4492 = new BitSet(new long[]{0x0000000000100000L}); 15644 public static final BitSet FOLLOW_COMMA_in_insn_format21c_type4494 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0000000000000000L,0x0000000000000001L}); 15645 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format21c_type4496 = new BitSet(new long[]{0x0000000000000002L}); 15646 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_LAMBDA_in_insn_format21c_lambda4528 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15647 public static final BitSet FOLLOW_REGISTER_in_insn_format21c_lambda4530 = new BitSet(new long[]{0x0000000000100000L}); 15648 public static final BitSet FOLLOW_COMMA_in_insn_format21c_lambda4532 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000200L}); 15649 public static final BitSet FOLLOW_STRING_LITERAL_in_insn_format21c_lambda4534 = new BitSet(new long[]{0x0000000000000002L}); 15650 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_METHOD_in_insn_format21c_method4566 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15651 public static final BitSet FOLLOW_REGISTER_in_insn_format21c_method4568 = new BitSet(new long[]{0x0000000000100000L}); 15652 public static final BitSet FOLLOW_COMMA_in_insn_format21c_method4570 = new BitSet(new long[]{0xD1F95C8000808550L,0x00000000020FB1B7L,0xA068000000000000L,0x0000000000003045L}); 15653 public static final BitSet FOLLOW_method_reference_in_insn_format21c_method4572 = new BitSet(new long[]{0x0000000000000002L}); 15654 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21ih_in_insn_format21ih4604 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15655 public static final BitSet FOLLOW_REGISTER_in_insn_format21ih4606 = new BitSet(new long[]{0x0000000000100000L}); 15656 public static final BitSet FOLLOW_COMMA_in_insn_format21ih4608 = new BitSet(new long[]{0x000000C000004C00L,0x0000000000000000L,0x8024000000000000L,0x0000000000000020L}); 15657 public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_format21ih4610 = new BitSet(new long[]{0x0000000000000002L}); 15658 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21lh_in_insn_format21lh4642 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15659 public static final BitSet FOLLOW_REGISTER_in_insn_format21lh4644 = new BitSet(new long[]{0x0000000000100000L}); 15660 public static final BitSet FOLLOW_COMMA_in_insn_format21lh4646 = new BitSet(new long[]{0x000000C000004C00L,0x0000000000000000L,0x8024000000000000L,0x0000000000000020L}); 15661 public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_format21lh4648 = new BitSet(new long[]{0x0000000000000002L}); 15662 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21s_in_insn_format21s4680 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15663 public static final BitSet FOLLOW_REGISTER_in_insn_format21s4682 = new BitSet(new long[]{0x0000000000100000L}); 15664 public static final BitSet FOLLOW_COMMA_in_insn_format21s4684 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x8024000000000000L,0x0000000000000020L}); 15665 public static final BitSet FOLLOW_integral_literal_in_insn_format21s4686 = new BitSet(new long[]{0x0000000000000002L}); 15666 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21t_in_insn_format21t4718 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15667 public static final BitSet FOLLOW_REGISTER_in_insn_format21t4720 = new BitSet(new long[]{0x0000000000100000L}); 15668 public static final BitSet FOLLOW_COMMA_in_insn_format21t4722 = new BitSet(new long[]{0x0000000000080000L}); 15669 public static final BitSet FOLLOW_label_ref_in_insn_format21t4724 = new BitSet(new long[]{0x0000000000000002L}); 15670 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22b_in_insn_format22b4756 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15671 public static final BitSet FOLLOW_REGISTER_in_insn_format22b4758 = new BitSet(new long[]{0x0000000000100000L}); 15672 public static final BitSet FOLLOW_COMMA_in_insn_format22b4760 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15673 public static final BitSet FOLLOW_REGISTER_in_insn_format22b4762 = new BitSet(new long[]{0x0000000000100000L}); 15674 public static final BitSet FOLLOW_COMMA_in_insn_format22b4764 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x8024000000000000L,0x0000000000000020L}); 15675 public static final BitSet FOLLOW_integral_literal_in_insn_format22b4766 = new BitSet(new long[]{0x0000000000000002L}); 15676 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_FIELD_in_insn_format22c_field4800 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15677 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_field4802 = new BitSet(new long[]{0x0000000000100000L}); 15678 public static final BitSet FOLLOW_COMMA_in_insn_format22c_field4804 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15679 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_field4806 = new BitSet(new long[]{0x0000000000100000L}); 15680 public static final BitSet FOLLOW_COMMA_in_insn_format22c_field4808 = new BitSet(new long[]{0xD1F95C8000808550L,0x00000000020FB1B7L,0xA068000000000000L,0x0000000000003045L}); 15681 public static final BitSet FOLLOW_field_reference_in_insn_format22c_field4810 = new BitSet(new long[]{0x0000000000000002L}); 15682 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_FIELD_ODEX_in_insn_format22c_field_odex4844 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15683 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_field_odex4846 = new BitSet(new long[]{0x0000000000100000L}); 15684 public static final BitSet FOLLOW_COMMA_in_insn_format22c_field_odex4848 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15685 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_field_odex4850 = new BitSet(new long[]{0x0000000000100000L}); 15686 public static final BitSet FOLLOW_COMMA_in_insn_format22c_field_odex4852 = new BitSet(new long[]{0xD1F95C8000808550L,0x00000000020FB1B7L,0xA068000000000000L,0x0000000000003045L}); 15687 public static final BitSet FOLLOW_field_reference_in_insn_format22c_field_odex4854 = new BitSet(new long[]{0x0000000000000002L}); 15688 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_TYPE_in_insn_format22c_type4894 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15689 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_type4896 = new BitSet(new long[]{0x0000000000100000L}); 15690 public static final BitSet FOLLOW_COMMA_in_insn_format22c_type4898 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15691 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_type4900 = new BitSet(new long[]{0x0000000000100000L}); 15692 public static final BitSet FOLLOW_COMMA_in_insn_format22c_type4902 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0000000000000000L,0x0000000000000001L}); 15693 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format22c_type4904 = new BitSet(new long[]{0x0000000000000002L}); 15694 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_STRING_in_insn_format22c_string4938 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15695 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_string4940 = new BitSet(new long[]{0x0000000000100000L}); 15696 public static final BitSet FOLLOW_COMMA_in_insn_format22c_string4942 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15697 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_string4944 = new BitSet(new long[]{0x0000000000100000L}); 15698 public static final BitSet FOLLOW_COMMA_in_insn_format22c_string4946 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000200L}); 15699 public static final BitSet FOLLOW_STRING_LITERAL_in_insn_format22c_string4948 = new BitSet(new long[]{0x0000000000000002L}); 15700 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22cs_FIELD_in_insn_format22cs_field4982 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15701 public static final BitSet FOLLOW_REGISTER_in_insn_format22cs_field4984 = new BitSet(new long[]{0x0000000000100000L}); 15702 public static final BitSet FOLLOW_COMMA_in_insn_format22cs_field4986 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15703 public static final BitSet FOLLOW_REGISTER_in_insn_format22cs_field4988 = new BitSet(new long[]{0x0000000000100000L}); 15704 public static final BitSet FOLLOW_COMMA_in_insn_format22cs_field4990 = new BitSet(new long[]{0x0000002000000000L}); 15705 public static final BitSet FOLLOW_FIELD_OFFSET_in_insn_format22cs_field4992 = new BitSet(new long[]{0x0000000000000002L}); 15706 public static final BitSet FOLLOW_instruction_format22s_in_insn_format22s5013 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15707 public static final BitSet FOLLOW_REGISTER_in_insn_format22s5015 = new BitSet(new long[]{0x0000000000100000L}); 15708 public static final BitSet FOLLOW_COMMA_in_insn_format22s5017 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15709 public static final BitSet FOLLOW_REGISTER_in_insn_format22s5019 = new BitSet(new long[]{0x0000000000100000L}); 15710 public static final BitSet FOLLOW_COMMA_in_insn_format22s5021 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x8024000000000000L,0x0000000000000020L}); 15711 public static final BitSet FOLLOW_integral_literal_in_insn_format22s5023 = new BitSet(new long[]{0x0000000000000002L}); 15712 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22t_in_insn_format22t5057 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15713 public static final BitSet FOLLOW_REGISTER_in_insn_format22t5059 = new BitSet(new long[]{0x0000000000100000L}); 15714 public static final BitSet FOLLOW_COMMA_in_insn_format22t5061 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15715 public static final BitSet FOLLOW_REGISTER_in_insn_format22t5063 = new BitSet(new long[]{0x0000000000100000L}); 15716 public static final BitSet FOLLOW_COMMA_in_insn_format22t5065 = new BitSet(new long[]{0x0000000000080000L}); 15717 public static final BitSet FOLLOW_label_ref_in_insn_format22t5067 = new BitSet(new long[]{0x0000000000000002L}); 15718 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22x_in_insn_format22x5101 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15719 public static final BitSet FOLLOW_REGISTER_in_insn_format22x5103 = new BitSet(new long[]{0x0000000000100000L}); 15720 public static final BitSet FOLLOW_COMMA_in_insn_format22x5105 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15721 public static final BitSet FOLLOW_REGISTER_in_insn_format22x5107 = new BitSet(new long[]{0x0000000000000002L}); 15722 public static final BitSet FOLLOW_INSTRUCTION_FORMAT23x_in_insn_format23x5139 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15723 public static final BitSet FOLLOW_REGISTER_in_insn_format23x5141 = new BitSet(new long[]{0x0000000000100000L}); 15724 public static final BitSet FOLLOW_COMMA_in_insn_format23x5143 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15725 public static final BitSet FOLLOW_REGISTER_in_insn_format23x5145 = new BitSet(new long[]{0x0000000000100000L}); 15726 public static final BitSet FOLLOW_COMMA_in_insn_format23x5147 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15727 public static final BitSet FOLLOW_REGISTER_in_insn_format23x5149 = new BitSet(new long[]{0x0000000000000002L}); 15728 public static final BitSet FOLLOW_INSTRUCTION_FORMAT25x_in_insn_format25x5183 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15729 public static final BitSet FOLLOW_REGISTER_in_insn_format25x5185 = new BitSet(new long[]{0x0000000000100000L}); 15730 public static final BitSet FOLLOW_COMMA_in_insn_format25x5187 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0080000000000000L}); 15731 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format25x5189 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15732 public static final BitSet FOLLOW_register_list_in_insn_format25x5191 = new BitSet(new long[]{0x0000000000020000L}); 15733 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format25x5193 = new BitSet(new long[]{0x0000000000000002L}); 15734 public static final BitSet FOLLOW_INSTRUCTION_FORMAT30t_in_insn_format30t5225 = new BitSet(new long[]{0x0000000000080000L}); 15735 public static final BitSet FOLLOW_label_ref_in_insn_format30t5227 = new BitSet(new long[]{0x0000000000000002L}); 15736 public static final BitSet FOLLOW_INSTRUCTION_FORMAT31c_in_insn_format31c5257 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15737 public static final BitSet FOLLOW_REGISTER_in_insn_format31c5259 = new BitSet(new long[]{0x0000000000100000L}); 15738 public static final BitSet FOLLOW_COMMA_in_insn_format31c5261 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000200L}); 15739 public static final BitSet FOLLOW_STRING_LITERAL_in_insn_format31c5263 = new BitSet(new long[]{0x0000000000000002L}); 15740 public static final BitSet FOLLOW_instruction_format31i_in_insn_format31i5294 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15741 public static final BitSet FOLLOW_REGISTER_in_insn_format31i5296 = new BitSet(new long[]{0x0000000000100000L}); 15742 public static final BitSet FOLLOW_COMMA_in_insn_format31i5298 = new BitSet(new long[]{0x000000C000004C00L,0x0000000000000000L,0x8024000000000000L,0x0000000000000020L}); 15743 public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_format31i5300 = new BitSet(new long[]{0x0000000000000002L}); 15744 public static final BitSet FOLLOW_INSTRUCTION_FORMAT31t_in_insn_format31t5332 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15745 public static final BitSet FOLLOW_REGISTER_in_insn_format31t5334 = new BitSet(new long[]{0x0000000000100000L}); 15746 public static final BitSet FOLLOW_COMMA_in_insn_format31t5336 = new BitSet(new long[]{0x0000000000080000L}); 15747 public static final BitSet FOLLOW_label_ref_in_insn_format31t5338 = new BitSet(new long[]{0x0000000000000002L}); 15748 public static final BitSet FOLLOW_INSTRUCTION_FORMAT32x_in_insn_format32x5370 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15749 public static final BitSet FOLLOW_REGISTER_in_insn_format32x5372 = new BitSet(new long[]{0x0000000000100000L}); 15750 public static final BitSet FOLLOW_COMMA_in_insn_format32x5374 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15751 public static final BitSet FOLLOW_REGISTER_in_insn_format32x5376 = new BitSet(new long[]{0x0000000000000002L}); 15752 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_METHOD_in_insn_format35c_method5408 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0080000000000000L}); 15753 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format35c_method5410 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15754 public static final BitSet FOLLOW_register_list_in_insn_format35c_method5412 = new BitSet(new long[]{0x0000000000020000L}); 15755 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format35c_method5414 = new BitSet(new long[]{0x0000000000100000L}); 15756 public static final BitSet FOLLOW_COMMA_in_insn_format35c_method5416 = new BitSet(new long[]{0xD1F95C8000808550L,0x00000000020FB1B7L,0xA068000000000000L,0x0000000000003045L}); 15757 public static final BitSet FOLLOW_method_reference_in_insn_format35c_method5418 = new BitSet(new long[]{0x0000000000000002L}); 15758 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_TYPE_in_insn_format35c_type5450 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0080000000000000L}); 15759 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format35c_type5452 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15760 public static final BitSet FOLLOW_register_list_in_insn_format35c_type5454 = new BitSet(new long[]{0x0000000000020000L}); 15761 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format35c_type5456 = new BitSet(new long[]{0x0000000000100000L}); 15762 public static final BitSet FOLLOW_COMMA_in_insn_format35c_type5458 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0000000000000000L,0x0000000000000001L}); 15763 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format35c_type5460 = new BitSet(new long[]{0x0000000000000002L}); 15764 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_METHOD_ODEX_in_insn_format35c_method_odex5492 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0080000000000000L}); 15765 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format35c_method_odex5494 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15766 public static final BitSet FOLLOW_register_list_in_insn_format35c_method_odex5496 = new BitSet(new long[]{0x0000000000020000L}); 15767 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format35c_method_odex5498 = new BitSet(new long[]{0x0000000000100000L}); 15768 public static final BitSet FOLLOW_COMMA_in_insn_format35c_method_odex5500 = new BitSet(new long[]{0xD1F95C8000808550L,0x00000000020FB1B7L,0xA068000000000000L,0x0000000000003045L}); 15769 public static final BitSet FOLLOW_method_reference_in_insn_format35c_method_odex5502 = new BitSet(new long[]{0x0000000000000002L}); 15770 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35mi_METHOD_in_insn_format35mi_method5523 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0080000000000000L}); 15771 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format35mi_method5525 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15772 public static final BitSet FOLLOW_register_list_in_insn_format35mi_method5527 = new BitSet(new long[]{0x0000000000020000L}); 15773 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format35mi_method5529 = new BitSet(new long[]{0x0000000000100000L}); 15774 public static final BitSet FOLLOW_COMMA_in_insn_format35mi_method5531 = new BitSet(new long[]{0x0000020000000000L}); 15775 public static final BitSet FOLLOW_INLINE_INDEX_in_insn_format35mi_method5533 = new BitSet(new long[]{0x0000000000000002L}); 15776 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35ms_METHOD_in_insn_format35ms_method5554 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0080000000000000L}); 15777 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format35ms_method5556 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15778 public static final BitSet FOLLOW_register_list_in_insn_format35ms_method5558 = new BitSet(new long[]{0x0000000000020000L}); 15779 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format35ms_method5560 = new BitSet(new long[]{0x0000000000100000L}); 15780 public static final BitSet FOLLOW_COMMA_in_insn_format35ms_method5562 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 15781 public static final BitSet FOLLOW_VTABLE_INDEX_in_insn_format35ms_method5564 = new BitSet(new long[]{0x0000000000000002L}); 15782 public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rc_METHOD_in_insn_format3rc_method5585 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0080000000000000L}); 15783 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format3rc_method5587 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15784 public static final BitSet FOLLOW_register_range_in_insn_format3rc_method5589 = new BitSet(new long[]{0x0000000000020000L}); 15785 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format3rc_method5591 = new BitSet(new long[]{0x0000000000100000L}); 15786 public static final BitSet FOLLOW_COMMA_in_insn_format3rc_method5593 = new BitSet(new long[]{0xD1F95C8000808550L,0x00000000020FB1B7L,0xA068000000000000L,0x0000000000003045L}); 15787 public static final BitSet FOLLOW_method_reference_in_insn_format3rc_method5595 = new BitSet(new long[]{0x0000000000000002L}); 15788 public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rc_METHOD_ODEX_in_insn_format3rc_method_odex5627 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0080000000000000L}); 15789 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format3rc_method_odex5629 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15790 public static final BitSet FOLLOW_register_list_in_insn_format3rc_method_odex5631 = new BitSet(new long[]{0x0000000000020000L}); 15791 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format3rc_method_odex5633 = new BitSet(new long[]{0x0000000000100000L}); 15792 public static final BitSet FOLLOW_COMMA_in_insn_format3rc_method_odex5635 = new BitSet(new long[]{0xD1F95C8000808550L,0x00000000020FB1B7L,0xA068000000000000L,0x0000000000003045L}); 15793 public static final BitSet FOLLOW_method_reference_in_insn_format3rc_method_odex5637 = new BitSet(new long[]{0x0000000000000002L}); 15794 public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rc_TYPE_in_insn_format3rc_type5658 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0080000000000000L}); 15795 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format3rc_type5660 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15796 public static final BitSet FOLLOW_register_range_in_insn_format3rc_type5662 = new BitSet(new long[]{0x0000000000020000L}); 15797 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format3rc_type5664 = new BitSet(new long[]{0x0000000000100000L}); 15798 public static final BitSet FOLLOW_COMMA_in_insn_format3rc_type5666 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0000000000000000L,0x0000000000000001L}); 15799 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format3rc_type5668 = new BitSet(new long[]{0x0000000000000002L}); 15800 public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rmi_METHOD_in_insn_format3rmi_method5700 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0080000000000000L}); 15801 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format3rmi_method5702 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15802 public static final BitSet FOLLOW_register_range_in_insn_format3rmi_method5704 = new BitSet(new long[]{0x0000000000020000L}); 15803 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format3rmi_method5706 = new BitSet(new long[]{0x0000000000100000L}); 15804 public static final BitSet FOLLOW_COMMA_in_insn_format3rmi_method5708 = new BitSet(new long[]{0x0000020000000000L}); 15805 public static final BitSet FOLLOW_INLINE_INDEX_in_insn_format3rmi_method5710 = new BitSet(new long[]{0x0000000000000002L}); 15806 public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rms_METHOD_in_insn_format3rms_method5731 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0080000000000000L}); 15807 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format3rms_method5733 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15808 public static final BitSet FOLLOW_register_range_in_insn_format3rms_method5735 = new BitSet(new long[]{0x0000000000020000L}); 15809 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format3rms_method5737 = new BitSet(new long[]{0x0000000000100000L}); 15810 public static final BitSet FOLLOW_COMMA_in_insn_format3rms_method5739 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 15811 public static final BitSet FOLLOW_VTABLE_INDEX_in_insn_format3rms_method5741 = new BitSet(new long[]{0x0000000000000002L}); 15812 public static final BitSet FOLLOW_INSTRUCTION_FORMAT51l_in_insn_format51l5762 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15813 public static final BitSet FOLLOW_REGISTER_in_insn_format51l5764 = new BitSet(new long[]{0x0000000000100000L}); 15814 public static final BitSet FOLLOW_COMMA_in_insn_format51l5766 = new BitSet(new long[]{0x000000C000C04C00L,0x0000000000000000L,0x8024000000000000L,0x0000000000000020L}); 15815 public static final BitSet FOLLOW_fixed_literal_in_insn_format51l5768 = new BitSet(new long[]{0x0000000000000002L}); 15816 public static final BitSet FOLLOW_ARRAY_DATA_DIRECTIVE_in_insn_array_data_directive5795 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x8020000000000000L}); 15817 public static final BitSet FOLLOW_parsed_integer_literal_in_insn_array_data_directive5801 = new BitSet(new long[]{0x000000C002C04C00L,0x0000000000000000L,0x8024000000000000L,0x0000000000000020L}); 15818 public static final BitSet FOLLOW_fixed_literal_in_insn_array_data_directive5813 = new BitSet(new long[]{0x000000C002C04C00L,0x0000000000000000L,0x8024000000000000L,0x0000000000000020L}); 15819 public static final BitSet FOLLOW_END_ARRAY_DATA_DIRECTIVE_in_insn_array_data_directive5816 = new BitSet(new long[]{0x0000000000000002L}); 15820 public static final BitSet FOLLOW_PACKED_SWITCH_DIRECTIVE_in_insn_packed_switch_directive5862 = new BitSet(new long[]{0x000000C000004C00L,0x0000000000000000L,0x8024000000000000L,0x0000000000000020L}); 15821 public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_packed_switch_directive5868 = new BitSet(new long[]{0x0000000020080000L}); 15822 public static final BitSet FOLLOW_label_ref_in_insn_packed_switch_directive5874 = new BitSet(new long[]{0x0000000020080000L}); 15823 public static final BitSet FOLLOW_END_PACKED_SWITCH_DIRECTIVE_in_insn_packed_switch_directive5881 = new BitSet(new long[]{0x0000000000000002L}); 15824 public static final BitSet FOLLOW_SPARSE_SWITCH_DIRECTIVE_in_insn_sparse_switch_directive5955 = new BitSet(new long[]{0x000000C080004C00L,0x0000000000000000L,0x8024000000000000L,0x0000000000000020L}); 15825 public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_sparse_switch_directive5962 = new BitSet(new long[]{0x0000000000000200L}); 15826 public static final BitSet FOLLOW_ARROW_in_insn_sparse_switch_directive5964 = new BitSet(new long[]{0x0000000000080000L}); 15827 public static final BitSet FOLLOW_label_ref_in_insn_sparse_switch_directive5966 = new BitSet(new long[]{0x000000C080004C00L,0x0000000000000000L,0x8024000000000000L,0x0000000000000020L}); 15828 public static final BitSet FOLLOW_END_SPARSE_SWITCH_DIRECTIVE_in_insn_sparse_switch_directive5974 = new BitSet(new long[]{0x0000000000000002L}); 15829 } 15830