java-packages/java-cup
SHA256
7
0
Fork 0
forked from pool/java-cup
Code Pull Requests Activity

OBS-URL: https://build.opensuse.org/package/show/Java:packages/java-cup?expand=0&rev=20

Browse Source
This commit is contained in:
Fridrich Strba
2022-01-11 14:56:58 +00:00
committed by Git OBS Bridge
parent 97fe44708b
commit 00f26dc6a8
14 changed files with 576 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files

397
java-cup-java8.patch Normal file
View File

@@ -0,0 +1,397 @@
--- a/build.xml
+++ b/build.xml
@@ -56,7 +56,7 @@
</target>
<target name="compile" depends="jflex">
- <javac srcdir="${java}" destdir="${classes}" verbose="off" listfiles="off" debug="on" source="10" target="10">
+ <javac srcdir="${java}" destdir="${classes}" verbose="off" listfiles="off" debug="on" source="1.8" target="1.8">
<classpath refid="libraries"/>
<compilerarg value="-Xlint:unchecked" />
<compilerarg value="-Xdiags:verbose" />
--- a/src/java/java_cup/Main.java
+++ b/src/java/java_cup/Main.java
@@ -527,7 +527,7 @@ public class Main {
protected static void check_unused() {
/* check for unused terminals */
- for (var term : terminal.all()) {
+ for (terminal term : terminal.all()) {
/* don't issue a message for EOF */
if (term == terminal.EOF)
continue;
@@ -547,7 +547,7 @@ public class Main {
}
/* check for unused non terminals */
- for (var nt:non_terminal.all()){
+ for (non_terminal nt:non_terminal.all()){
/* is this one unused */
if (nt.use_count() == 0) {
/* count and warn if we are doing warnings */
@@ -613,7 +613,7 @@ public class Main {
System.err.println(" Filling in tables...");
action_table = new parse_action_table();
reduce_table = new parse_reduce_table();
- for (var lst:lalr_state.all_states()){
+ for (lalr_state lst:lalr_state.all_states()){
lst.build_table_entries(action_table, reduce_table);
}
@@ -846,7 +846,7 @@ public class Main {
lalr_state ordered[] = new lalr_state[lalr_state.number()];
/* put the states in sorted order for a nicer display */
- for (var st : lalr_state.all_states()){
+ for (lalr_state st : lalr_state.all_states()){
ordered[st.index()] = st;
}
--- a/src/java/java_cup/emit.java
+++ b/src/java/java_cup/emit.java
@@ -624,14 +624,14 @@ public class emit {
/* collect up the productions in order */
all_prods = new production[production.number()];
- for (var prod:production.all()){
+ for (production prod:production.all()){
all_prods[prod.index()] = prod;
}
// make short[][]
short[][] prod_table = new short[production.number()][2];
for (int i = 0; i < production.number(); i++) {
- var prod = all_prods[i];
+ production prod = all_prods[i];
// { lhs symbol , rhs size }
prod_table[i][0] = (short) prod.lhs().the_symbol().index();
prod_table[i][1] = (short) prod.rhs_length();
@@ -818,12 +818,12 @@ public class emit {
nchar = do_newline(out, nchar, nbytes);
nbytes += do_escaped(out, (char) (sa.length & 0xFFFF));
nchar = do_newline(out, nchar, nbytes);
- for (var element:sa) {
+ for (short[] element:sa) {
nbytes += do_escaped(out, (char) (element.length >> 16));
nchar = do_newline(out, nchar, nbytes);
nbytes += do_escaped(out, (char) (element.length & 0xFFFF));
nchar = do_newline(out, nchar, nbytes);
- for (var element2 : element) {
+ for (short element2 : element) {
// contents of string are (value+2) to allow for common -1, 0 cases
// (UTF-8 encoding is most efficient for 0<c<0x80)
nbytes += do_escaped(out, (char) (2 + element2));
--- a/src/java/java_cup/lalr_item_set.java
+++ b/src/java/java_cup/lalr_item_set.java
@@ -206,7 +206,7 @@ public class lalr_item_set implements Iterable<lalr_item> {
public lalr_item get_one() throws internal_error {
if (_all.values().size() == 0)
return null;
- var result = iterator().next();
+ lalr_item result = iterator().next();
remove(result);
return result;
}
@@ -255,30 +255,30 @@ public class lalr_item_set implements Iterable<lalr_item> {
hashcode_cache = null;
/* each current element needs to be considered */
- var consider = new lalr_item_set(this);
+ lalr_item_set consider = new lalr_item_set(this);
/* repeat this until there is nothing else to consider */
while (consider.size() > 0) {
/* get one item to consider */
- var itm = consider.get_one();
+ lalr_item itm = consider.get_one();
/* do we have a dot before a non terminal */
- var nt = itm.dot_before_nt();
+ non_terminal nt = itm.dot_before_nt();
if (nt != null) {
/* create the lookahead set based on first after dot */
- var new_lookaheads = itm.calc_lookahead(itm.lookahead());
+ terminal_set new_lookaheads = itm.calc_lookahead(itm.lookahead());
/* are we going to need to propagate our lookahead to new item */
- var need_prop = itm.lookahead_visible();
+ boolean need_prop = itm.lookahead_visible();
/* create items for each production of that non term */
- for (var prod : nt.productions()) {
+ for (production prod : nt.productions()) {
/* create new item with dot at start and that lookahead */
- var new_itm = new lalr_item(prod, new terminal_set(new_lookaheads));
+ lalr_item new_itm = new lalr_item(prod, new terminal_set(new_lookaheads));
/* add/merge item into the set */
- var add_itm = add(new_itm);
+ lalr_item add_itm = add(new_itm);
/* if propagation is needed link to that item */
if (need_prop)
itm.add_propagate(add_itm);
@@ -335,7 +335,7 @@ public class lalr_item_set implements Iterable<lalr_item> {
// CSA fix! we'd *like* to hash just a few elements, but
// that means equal sets will have inequal hashcodes, which
// we're not allowed (by contract) to do. So hash them all.
- for (var e : this)
+ for (lalr_item e : this)
result ^= e.hashCode();
hashcode_cache = Integer.valueOf(result);
@@ -352,7 +352,7 @@ public class lalr_item_set implements Iterable<lalr_item> {
StringBuilder result = new StringBuilder();
result.append("{\n");
- for (var e : this)
+ for (lalr_item e : this)
result.append(" " + e + "\n");
result.append("}");
--- a/src/java/java_cup/lalr_state.java
+++ b/src/java/java_cup/lalr_state.java
@@ -187,14 +187,14 @@ public class lalr_state {
}
System.out.println("lalr_state [" + st.index() + "] {");
- for (var itm : st.items()) {
+ for (lalr_item itm : st.items()) {
System.out.print(" [");
System.out.print(itm.the_production().lhs().the_symbol().name());
System.out.print(" ::= ");
for (int i = 0; i < itm.the_production().rhs_length(); i++) {
if (i == itm.dot_pos())
System.out.print("\u00B7 ");
- var part = itm.the_production().rhs(i);
+ production_part part = itm.the_production().rhs(i);
if (part.is_action())
System.out.print("{action} ");
else
@@ -219,7 +219,7 @@ public class lalr_state {
*/
protected static void propagate_all_lookaheads() throws internal_error {
/* iterate across all states */
- for (var st : all_states())
+ for (lalr_state st : all_states())
st.propagate_lookaheads();
}
@@ -298,7 +298,7 @@ public class lalr_state {
/* build item with dot at front of start production and EOF lookahead */
start_items = new lalr_item_set();
- var start_itm = new lalr_item(start_prod);
+ lalr_item start_itm = new lalr_item(start_prod);
start_itm.lookahead().add(terminal.EOF);
start_items.add(start_itm);
@@ -319,29 +319,29 @@ public class lalr_state {
/* continue looking at new states until we have no more work to do */
while (!work_stack.empty()) {
/* remove a state from the work set */
- var st = work_stack.pop();
+ lalr_state st = work_stack.pop();
/* gather up all the symbols that appear before dots */
- var outgoing = new symbol_set();
- for (var itm : st.items()) {
+ symbol_set outgoing = new symbol_set();
+ for (lalr_item itm : st.items()) {
/* add the symbol before the dot (if any) to our collection */
- var sym = itm.symbol_after_dot();
+ symbol sym = itm.symbol_after_dot();
if (sym != null)
outgoing.add(sym);
}
/* now create a transition out for each individual symbol */
- for (var sym : outgoing) {
+ for (symbol sym : outgoing) {
/* will be keeping the set of items with propagate links */
- var linked_items = new lalr_item_set();
+ lalr_item_set linked_items = new lalr_item_set();
// gather up shifted versions of all the items that have this symbol before the
// dot
- var new_items = new lalr_item_set();
- for (var itm : st.items()) {
+ lalr_item_set new_items = new lalr_item_set();
+ for (lalr_item itm : st.items()) {
/* if this is the symbol we are working on now, add to set */
- var sym2 = itm.symbol_after_dot();
+ symbol sym2 = itm.symbol_after_dot();
if (sym.equals(sym2)) {
/* add to the kernel of the new state */
new_items.add(itm.shift());
@@ -353,7 +353,7 @@ public class lalr_state {
/* use new items as state kernel */
kernel = new lalr_item_set(new_items);
/* have we seen this one already? */
- var new_st = _all_kernels.get(kernel);
+ lalr_state new_st = _all_kernels.get(kernel);
/* if we haven't, build a new state out of the item set */
if (new_st == null) {
@@ -372,7 +372,7 @@ public class lalr_state {
/* otherwise relink propagation to items in existing state */
else {
/* walk through the items that have links to the new state */
- for (var fix_itm : linked_items) {
+ for (lalr_item fix_itm : linked_items) {
/* look at each propagate link out of that item */
for (int l = 0; l < fix_itm.propagate_items().size(); l++) {
@@ -410,7 +410,7 @@ public class lalr_state {
*/
protected void propagate_lookaheads() throws internal_error {
/* recursively propagate out from each item in the state */
- for (var itm : items())
+ for (lalr_item itm : items())
itm.propagate_lookaheads(null);
}
@@ -439,17 +439,17 @@ public class lalr_state {
* @param reduce_table the reduce-goto table to put entries in.
*/
public void build_table_entries(parse_action_table act_table, parse_reduce_table reduce_table) throws internal_error {
- var conflict_set = new terminal_set();
+ terminal_set conflict_set = new terminal_set();
/* pull out our rows from the tables */
- var our_act_row = act_table.under_state[index()];
- var our_red_row = reduce_table.under_state[index()];
+ parse_action_row our_act_row = act_table.under_state[index()];
+ parse_reduce_row our_red_row = reduce_table.under_state[index()];
/* consider each item in our state */
- for (var itm : items()) {
+ for (lalr_item itm : items()) {
/* if its completed (dot at end) then reduce under the lookahead */
if (itm.dot_at_end()) {
- var act = new reduce_action(itm.the_production());
+ reduce_action act = new reduce_action(itm.the_production());
/* consider each lookahead symbol */
for (int t = 0; t < terminal.number(); t++) {
@@ -463,7 +463,7 @@ public class lalr_state {
} else {
/* we now have at least one conflict */
terminal term = terminal.find(t);
- var other_act = our_act_row.under_term[t];
+ parse_action other_act = our_act_row.under_term[t];
/* if the other act was not a shift */
if ((other_act.kind() != parse_action.SHIFT) && (other_act.kind() != parse_action.NONASSOC)) {
@@ -490,9 +490,9 @@ public class lalr_state {
/* consider each outgoing transition */
for (lalr_transition trans = transitions(); trans != null; trans = trans.next()) {
/* if its on an terminal add a shift entry */
- var sym = trans.on_symbol();
+ symbol sym = trans.on_symbol();
if (!sym.is_non_term()) {
- var act = new shift_action(trans.to_state());
+ shift_action act = new shift_action(trans.to_state());
/* if we don't already have an action put this one in */
if (our_act_row.under_term[sym.index()].kind() == parse_action.ERROR) {
@@ -641,7 +641,7 @@ public class lalr_state {
boolean after_itm;
/* consider each element */
- for (var itm : items()) {
+ for (lalr_item itm : items()) {
/* clear the S/R conflict set for this item */
/* if it results in a reduce, it could be a conflict */
@@ -650,7 +650,7 @@ public class lalr_state {
after_itm = false;
/* compare this item against all others looking for conflicts */
- for (var compare : items()) {
+ for (lalr_item compare : items()) {
/* if this is the item, next one is after it */
if (itm == compare)
after_itm = true;
@@ -727,7 +727,7 @@ public class lalr_state {
int relevancecounter = 0;
/* find and report on all items that shift under our conflict symbol */
- for (var itm : items()) {
+ for (lalr_item itm : items()) {
/* only look if its not the same item and not a reduce */
if (itm != red_itm && !itm.dot_at_end()) {
--- a/src/java/java_cup/parse_action_table.java
+++ b/src/java/java_cup/parse_action_table.java
@@ -73,7 +73,7 @@ public class parse_action_table {
}
/* now go across every production and make sure we hit it */
- for (var prod : production.all()){
+ for (production prod : production.all()){
/* if we didn't hit it give a warning */
if (prod.num_reductions() == 0) {
/*
--- a/src/java/java_cup/symbol_set.java
+++ b/src/java/java_cup/symbol_set.java
@@ -90,8 +90,8 @@ public class symbol_set implements Iterable<symbol> {
not_null(other);
/* walk down our set and make sure every element is in the other */
- for (var e : this)
- if (!other.contains(e))
+ for (Iterator<symbol> e = iterator(); e.hasNext();)
+ if (!other.contains(e.next()))
return false;
/* they were all there */
return true;
@@ -155,8 +155,8 @@ public class symbol_set implements Iterable<symbol> {
not_null(other);
/* walk down the other set and do the adds individually */
- for (var e : other)
- result = add(e) || result;
+ for (Iterator<symbol> e = other.iterator(); e.hasNext();)
+ result = add(e.next()) || result;
return result;
}
@@ -172,8 +172,8 @@ public class symbol_set implements Iterable<symbol> {
not_null(other);
/* walk down the other set and do the removes individually */
- for (var s : other)
- remove(s);
+ for (Iterator<symbol> s = other.iterator(); s.hasNext();)
+ remove(s.next());
}
/* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */
@@ -212,8 +212,8 @@ public class symbol_set implements Iterable<symbol> {
int result = 0;
/* hash together codes from at most first 5 elements */
- for (var s : this)
- result ^= s.hashCode();
+ for (Iterator<symbol> s = iterator(); s.hasNext(); )
+ result ^= s.next().hashCode();
return result;
}
@@ -228,12 +228,12 @@ public class symbol_set implements Iterable<symbol> {
result = "{";
comma_flag = false;
- for (var s : this) {
+ for (Iterator<symbol> s = iterator(); s.hasNext();) {
if (comma_flag)
result += ", ";
else
comma_flag = true;
- result += s.name();
+ result += s.next().name();
}
result += "}";