jdk-sandbox: comparison src/java.xml/share/classes/com/sun/java_cup/internal/runtime/lr

equal deleted inserted replaced

-:d07d5f7cab35
+:e1a6c0168741
 /*
-* Copyright (c) 2003, 2005, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 protected Symbol cur_token;
 /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
 /** The parse stack itself. */
-protected Stack stack = new Stack();
+protected Stack<Symbol> stack = new Stack<>();
 /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
 /** Direct reference to the production table. */
 protected short[][] production_tab;
 * @param top       the index of the top element of the parse stack.
 */
 public abstract Symbol do_action(
 int       act_num,
 lr_parser parser,
-Stack     stack,
+Stack<Symbol>     stack,
 int       top)
 throws java.lang.Exception;
 /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
 throw new Error("Symbol recycling detected (fix your scanner).");
 /* current state is always on the top of the stack */
 /* look up action out of the current state with the current input */
-act = get_action(((Symbol)stack.peek()).parse_state, cur_token.sym);
+act = get_action((stack.peek()).parse_state, cur_token.sym);
 /* decode the action -- > 0 encodes shift */
 if (act > 0)
 {
 /* shift to the encoded state by pushing it on the stack */
 stack.pop();
 tos--;
 }
 /* look up the state to go to from the one popped back to */
-act = get_reduce(((Symbol)stack.peek()).parse_state, lhs_sym_num);
+act = get_reduce((stack.peek()).parse_state, lhs_sym_num);
 /* shift to that state */
 lhs_sym.parse_state = act;
 lhs_sym.used_by_parser = true;
 stack.push(lhs_sym);
 unrecovered_syntax_error(cur_token);
 /* just in case that wasn't fatal enough, end parse */
 done_parsing();
 } else {
-lhs_sym = (Symbol)stack.peek();
+lhs_sym = stack.peek();
 }
 }
 }
 return lhs_sym;
 }
 debug_message("============ Parse Stack Dump ============");
 /* dump the stack */
 for (int i=0; i<stack.size(); i++)
 {
-debug_message("Symbol: " + ((Symbol)stack.elementAt(i)).sym +
+debug_message("Symbol: " + (stack.get(i)).sym +
-" State: " + ((Symbol)stack.elementAt(i)).parse_state);
+" State: " + (stack.get(i)).parse_state);
 }
 debug_message("==========================================");
 }
 /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
 /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
 /** Do debug output for stack state. [CSA]
 */
 public void debug_stack() {
-StringBuffer sb=new StringBuffer("## STACK:");
+StringBuilder sb=new StringBuilder("## STACK:");
 for (int i=0; i<stack.size(); i++) {
-Symbol s = (Symbol) stack.elementAt(i);
+Symbol s = stack.get(i);
 sb.append(" <state "+s.parse_state+", sym "+s.sym+">");
 if ((i%3)==2 || (i==(stack.size()-1))) {
 debug_message(sb.toString());
-sb = new StringBuffer("         ");
+sb = new StringBuilder("         ");
 }
 }
 }
 /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
 /* current state is always on the top of the stack */
 //debug_stack();
 /* look up action out of the current state with the current input */
-act = get_action(((Symbol)stack.peek()).parse_state, cur_token.sym);
+act = get_action((stack.peek()).parse_state, cur_token.sym);
 /* decode the action -- > 0 encodes shift */
 if (act > 0)
 {
 /* shift to the encoded state by pushing it on the stack */
 stack.pop();
 tos--;
 }
 /* look up the state to go to from the one popped back to */
-act = get_reduce(((Symbol)stack.peek()).parse_state, lhs_sym_num);
+act = get_reduce((stack.peek()).parse_state, lhs_sym_num);
 debug_message("# Reduce rule: top state " +
-((Symbol)stack.peek()).parse_state +
+(stack.peek()).parse_state +
 ", lhs sym " + lhs_sym_num + " -> state " + act);
 /* shift to that state */
 lhs_sym.parse_state = act;
 lhs_sym.used_by_parser = true;
 unrecovered_syntax_error(cur_token);
 /* just in case that wasn't fatal enough, end parse */
 done_parsing();
 } else {
-lhs_sym = (Symbol)stack.peek();
+lhs_sym = stack.peek();
 }
 }
 }
 return lhs_sym;
 }
 *  state currently on the top of the (real) parse stack.
 */
 protected boolean shift_under_error()
 {
 /* is there a shift under error Symbol */
-return get_action(((Symbol)stack.peek()).parse_state, error_sym()) > 0;
+return get_action((stack.peek()).parse_state, error_sym()) > 0;
 }
 /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
 /** Put the (real) parse stack into error recovery configuration by
 int act;
 if (debug) debug_message("# Finding recovery state on stack");
 /* Remember the right-position of the top symbol on the stack */
-int right_pos = ((Symbol)stack.peek()).right;
+int right_pos = (stack.peek()).right;
-int left_pos  = ((Symbol)stack.peek()).left;
+int left_pos  = (stack.peek()).left;
 /* pop down until we can shift under error Symbol */
 while (!shift_under_error())
 {
 /* pop the stack */
 if (debug)
 debug_message("# Pop stack by one, state was # " +
-((Symbol)stack.peek()).parse_state);
+(stack.peek()).parse_state);
 left_pos = ((Symbol)stack.pop()).left;
 tos--;
 /* if we have hit bottom, we fail */
 if (stack.empty())
 return false;
 }
 }
 /* state on top of the stack can shift under error, find the shift */
-act = get_action(((Symbol)stack.peek()).parse_state, error_sym());
+act = get_action((stack.peek()).parse_state, error_sym());
 if (debug)
 {
 debug_message("# Recover state found (#" +
-((Symbol)stack.peek()).parse_state + ")");
+(stack.peek()).parse_state + ")");
 debug_message("# Shifting on error to state #" + (act-1));
 }
 /* build and shift a special error Symbol */
 error_token = new Symbol(error_sym(), left_pos, right_pos);
 if (debug)
 {
 debug_message("# Reparsing saved input with actions");
 debug_message("# Current Symbol is #" + cur_err_token().sym);
 debug_message("# Current state is #" +
-((Symbol)stack.peek()).parse_state);
+(stack.peek()).parse_state);
 }
 /* continue until we accept or have read all lookahead input */
 while(!_done_parsing)
 {
 /* current state is always on the top of the stack */
 /* look up action out of the current state with the current input */
 act =
-get_action(((Symbol)stack.peek()).parse_state, cur_err_token().sym);
+get_action((stack.peek()).parse_state, cur_err_token().sym);
 /* decode the action -- > 0 encodes shift */
 if (act > 0)
 {
 /* shift to the encoded state by pushing it on the stack */
 stack.pop();
 tos--;
 }
 /* look up the state to go to from the one popped back to */
-act = get_reduce(((Symbol)stack.peek()).parse_state, lhs_sym_num);
+act = get_reduce((stack.peek()).parse_state, lhs_sym_num);
 /* shift to that state */
 lhs_sym.parse_state = act;
 lhs_sym.used_by_parser = true;
 stack.push(lhs_sym);
 /** Utility function: unpacks parse tables from strings */
 protected static short[][] unpackFromStrings(String[] sa)
 {
 // Concatanate initialization strings.
-StringBuffer sb = new StringBuffer(sa[0]);
+StringBuilder sb = new StringBuilder(sa[0]);
 for (int i=1; i<sa.length; i++)
 sb.append(sa[i]);
 int n=0; // location in initialization string
 int size1 = (((int)sb.charAt(n))<<16) | ((int)sb.charAt(n+1)); n+=2;
 short[][] result = new short[size1][];

changeset 47359	e1a6c0168741
parent 47216	71c04702a3d5
child 47712	bde0215f1f70