/*-----------------------------------------------------------*/ /*--- Constructor(s) ----------------------------------------*/ /*-----------------------------------------------------------*/ /// <summary>Full constructor. /// </summary> /// <param name="prod">the production for the item. /// </param> /// <param name="pos"> the position of the "dot" within the production. /// </param> /// <param name="look">the set of lookahead symbols. /// /// </param> public lalr_item(production prod, int pos, terminal_set look) : base(prod, pos) { _lookahead = look; _propagate_items = new CUP.runtime.SymbolStack(); needs_propagation = true; }
/*-----------------------------------------------------------*/ /*--- General Methods ---------------------------------------*/ /*-----------------------------------------------------------*/ /// <summary>Propagate incoming lookaheads through this item to others need to /// be changed. /// </summary> /// <param name="incoming">symbols to potentially be added to lookahead of this item. /// /// </param> public virtual void propagate_lookaheads(terminal_set incoming) { bool change = false; /* if we don't need to propagate, then bail out now */ if (!needs_propagation && (incoming == null || incoming.empty())) { return; } /* if we have null incoming, treat as an empty set */ if (incoming != null) { /* add the incoming to the lookahead of this item */ change = lookahead().add(incoming); } /* if we changed or need it anyway, propagate across our links */ if (change || needs_propagation) { /* don't need to propagate again */ needs_propagation = false; /* propagate our lookahead into each item we are linked to */ for (int i = 0; i < propagate_items().Count; i++) { ((lalr_item)(propagate_items().Peek(propagate_items().Count - (i + 1)))).propagate_lookaheads(lookahead()); } } }
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ /// <summary>Equality comparison. /// </summary> public virtual bool equals(terminal_set other) { if (other == null) { return(false); } else { //UPGRADE_TODO: method 'java.util.BitSet.equals' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilBitSetequals_javalangObject"' return(_elements.Equals(other._elements)); } }
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ /// <summary>Calculate lookahead representing symbols that could appear after the /// symbol that the dot is currently in front of. Note: this routine must /// not be invoked before first sets and nullability has been calculated /// for all non terminals. /// </summary> public virtual terminal_set calc_lookahead(terminal_set lookahead_after) { terminal_set result; int pos; production_part part; symbol sym; /* sanity check */ if (dot_at_end()) { throw new internal_error("Attempt to calculate a lookahead set with a completed item"); } /* start with an empty result */ result = new terminal_set(); /* consider all nullable symbols after the one to the right of the dot */ for (pos = dot_pos() + 1; pos < the_production().rhs_length(); pos++) { part = the_production().rhs(pos); /* consider what kind of production part it is -- skip actions */ if (!part.is_action()) { sym = ((symbol_part)part).the_symbol(); /* if its a terminal add it in and we are done */ if (!sym.is_non_term()) { result.add((terminal)sym); return(result); } else { /* otherwise add in first set of the non terminal */ result.add(((non_terminal)sym).first_set()); /* if its nullable we continue adding, if not, we are done */ if (!((non_terminal)sym).nullable()) { return(result); } } } } /* if we get here everything past the dot was nullable * we add in the lookahead for after the production and we are done */ result.add(lookahead_after); return(result); }
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ /// <summary>Determine if this set is an (improper) subset of another. /// </summary> /// <param name="other">the set we are testing against. /// /// </param> public virtual bool is_subset_of(terminal_set other) { not_null(other); /* make a copy of the other set */ System.Collections.BitArray copy_other = (System.Collections.BitArray)other._elements.Clone(); /* and or in */ copy_other = copy_other.Or(_elements); /* if it hasn't changed, we were a subset */ return(BitArraysEqual(copy_other, other._elements)); /// copy_other.Equals(other._elements); }
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ /// <summary>Determine if this set intersects another. /// </summary> /// <param name="other">the other set in question. /// /// </param> public virtual bool intersects(terminal_set other) { not_null(other); /* make a copy of the other set */ System.Collections.BitArray copy = (System.Collections.BitArray)other._elements.Clone(); /* xor out our values */ //UPGRADE_NOTE: In .NET BitArrays must be of the same size to allow the 'System.Collections.BitArray.Xor' operation. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1083"' copy = copy.Xor(this._elements); /* see if its different */ //UPGRADE_TODO: method 'java.util.BitSet.equals' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilBitSetequals_javalangObject"' return(!BitArraysEqual(copy, other._elements)); // copy.Equals(other._elements); }
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ /// <summary>Add (union) in a complete set. /// </summary> /// <param name="other">the set being added. /// </param> /// <returns>true if this changes the set. /// /// </returns> public virtual bool add(terminal_set other) { not_null(other); /* make a copy */ System.Collections.BitArray copy = (System.Collections.BitArray)_elements.Clone(); /* or in the other set */ //UPGRADE_NOTE: In .NET BitArrays must be of the same size to allow the 'System.Collections.BitArray.Or' operation. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1083"' _elements = _elements.Or(other._elements); /* changed if we are not the same as the copy */ //UPGRADE_TODO: method 'java.util.BitSet.equals' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilBitSetequals_javalangObject"' return(!BitArraysEqual(_elements, copy)); // _elements.Equals(copy); }
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ /// <summary>Determine if this set is an (improper) superset of another. /// </summary> /// <param name="other">the set we are testing against. /// /// </param> public virtual bool is_superset_of(terminal_set other) { not_null(other); return(other.is_subset_of(this)); }
private void InitBlock() { _productions = new System.Collections.Hashtable(11); _first_set = new terminal_set(); }
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ /// <summary>Determine if this set intersects another. /// </summary> /// <param name="other">the other set in question. /// /// </param> public virtual bool intersects(terminal_set other) { not_null(other); /* make a copy of the other set */ System.Collections.BitArray copy = (System.Collections.BitArray) other._elements.Clone(); /* xor out our values */ //UPGRADE_NOTE: In .NET BitArrays must be of the same size to allow the 'System.Collections.BitArray.Xor' operation. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1083"' copy = copy.Xor(this._elements); /* see if its different */ //UPGRADE_TODO: method 'java.util.BitSet.equals' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilBitSetequals_javalangObject"' return !BitArraysEqual(copy, other._elements); // copy.Equals(other._elements); }
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ /// <summary>Equality comparison. /// </summary> public virtual bool equals(terminal_set other) { if (other == null) return false; else { //UPGRADE_TODO: method 'java.util.BitSet.equals' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilBitSetequals_javalangObject"' return _elements.Equals(other._elements); } }
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ /// <summary>Calculate lookahead representing symbols that could appear after the /// symbol that the dot is currently in front of. Note: this routine must /// not be invoked before first sets and nullability has been calculated /// for all non terminals. /// </summary> public virtual terminal_set calc_lookahead(terminal_set lookahead_after) { terminal_set result; int pos; production_part part; symbol sym; /* sanity check */ if (dot_at_end()) throw new internal_error("Attempt to calculate a lookahead set with a completed item"); /* start with an empty result */ result = new terminal_set(); /* consider all nullable symbols after the one to the right of the dot */ for (pos = dot_pos() + 1; pos < the_production().rhs_length(); pos++) { part = the_production().rhs(pos); /* consider what kind of production part it is -- skip actions */ if (!part.is_action()) { sym = ((symbol_part) part).the_symbol(); /* if its a terminal add it in and we are done */ if (!sym.is_non_term()) { result.add((terminal) sym); return result; } else { /* otherwise add in first set of the non terminal */ result.add(((non_terminal) sym).first_set()); /* if its nullable we continue adding, if not, we are done */ if (!((non_terminal) sym).nullable()) return result; } } } /* if we get here everything past the dot was nullable we add in the lookahead for after the production and we are done */ result.add(lookahead_after); return result; }
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ /// <summary>Determine if this set is an (improper) subset of another. /// </summary> /// <param name="other">the set we are testing against. /// /// </param> public virtual bool is_subset_of(terminal_set other) { not_null(other); /* make a copy of the other set */ System.Collections.BitArray copy_other = (System.Collections.BitArray) other._elements.Clone(); /* and or in */ copy_other = copy_other.Or(_elements); /* if it hasn't changed, we were a subset */ return BitArraysEqual(copy_other, other._elements); /// copy_other.Equals(other._elements); }
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ /// <summary>Determine if this set is an (improper) superset of another. /// </summary> /// <param name="other">the set we are testing against. /// /// </param> public virtual bool is_superset_of(terminal_set other) { not_null(other); return other.is_subset_of(this); }
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ /// <summary>Constructor for cloning from another set. /// </summary> /// <param name="other">the set we are cloning from. /// /// </param> public terminal_set(terminal_set other) { not_null(other); _elements = (System.Collections.BitArray) other._elements.Clone(); }
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ /// <summary>Produce warning messages for all conflicts found in this state. /// </summary> protected internal virtual void report_conflicts(terminal_set conflict_set) { lalr_item itm, compare; //symbol shift_sym; bool after_itm; /* consider each element */ //UPGRADE_TODO: method 'java.util.Enumeration.hasMoreElements' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilEnumerationhasMoreElements"' for (System.Collections.IEnumerator itms = items().all(); itms.MoveNext();) { //UPGRADE_TODO: method 'java.util.Enumeration.nextElement' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilEnumerationnextElement"' itm = (lalr_item)itms.Current; /* clear the S/R conflict set for this item */ /* if it results in a reduce, it could be a conflict */ if (itm.dot_at_end()) { /* not yet after itm */ after_itm = false; /* compare this item against all others looking for conflicts */ //UPGRADE_TODO: method 'java.util.Enumeration.hasMoreElements' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilEnumerationhasMoreElements"' for (System.Collections.IEnumerator comps = items().all(); comps.MoveNext();) { //UPGRADE_TODO: method 'java.util.Enumeration.nextElement' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilEnumerationnextElement"' compare = (lalr_item)comps.Current; /* if this is the item, next one is after it */ if (itm == compare) { after_itm = true; } /* only look at it if its not the same item */ if (itm != compare) { /* is it a reduce */ if (compare.dot_at_end()) { /* only look at reduces after itm */ if (after_itm) { if (compare.lookahead().intersects(itm.lookahead())) { report_reduce_reduce(itm, compare); } } } } } /* report S/R conflicts under all the symbols we conflict under */ for (int t = 0; t < terminal.number(); t++) { if (conflict_set.contains(t)) { report_shift_reduce(itm, t); } } } } }
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ /// <summary>Fill in the parse table entries for this state. There are two /// parse tables that encode the viable prefix recognition machine, an /// action table and a reduce-goto table. The rows in each table /// correspond to states of the machine. The columns of the action table /// are indexed by terminal symbols and correspond to either transitions /// out of the state (shift entries) or reductions from the state to some /// previous state saved on the stack (reduce entries). All entries in the /// action table that are not shifts or reduces, represent errors. The /// reduce-goto table is indexed by non terminals and represents transitions /// out of a state on that non-terminal.<p> /// Conflicts occur if more than one action needs to go in one entry of the /// action table (this cannot happen with the reduce-goto table). Conflicts /// are resolved by always shifting for shift/reduce conflicts and choosing /// the lowest numbered production (hence the one that appeared first in /// the specification) in reduce/reduce conflicts. All conflicts are /// reported and if more conflicts are detected than were declared by the /// user, code generation is aborted. /// * /// </summary> /// <param name="act_table"> the action table to put entries in. /// </param> /// <param name="reduce_table">the reduce-goto table to put entries in. /// /// </param> public virtual void build_table_entries(parse_action_table act_table, parse_reduce_table reduce_table) { parse_action_row our_act_row; parse_reduce_row our_red_row; lalr_item itm; parse_action act, other_act; symbol sym; terminal_set conflict_set = new terminal_set(); /* pull out our rows from the tables */ our_act_row = act_table.under_state[index()]; our_red_row = reduce_table.under_state[index()]; /* consider each item in our state */ //UPGRADE_TODO: method 'java.util.Enumeration.hasMoreElements' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilEnumerationhasMoreElements"' for (System.Collections.IEnumerator i = items().all(); i.MoveNext();) { //UPGRADE_TODO: method 'java.util.Enumeration.nextElement' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilEnumerationnextElement"' itm = (lalr_item)i.Current; /* if its completed (dot at end) then reduce under the lookahead */ if (itm.dot_at_end()) { act = new reduce_action(itm.the_production()); /* consider each lookahead symbol */ for (int t = 0; t < terminal.number(); t++) { /* skip over the ones not in the lookahead */ if (!itm.lookahead().contains(t)) { continue; } /* if we don't already have an action put this one in */ if (our_act_row.under_term[t].kind() == parse_action.ERROR) { our_act_row.under_term[t] = act; } else { /* we now have at least one conflict */ terminal term = terminal.find(t); 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)) { /* if we have lower index hence priority, replace it*/ if (itm.the_production().index() < ((reduce_action)other_act).reduce_with().index()) { /* replace the action */ our_act_row.under_term[t] = act; } } else { /* Check precedences,see if problem is correctable */ if (fix_with_precedence(itm.the_production(), t, our_act_row, act)) { term = null; } } if (term != null) { conflict_set.add(term); } } } } } /* consider each outgoing transition */ for (lalr_transition trans = transitions(); trans != null; trans = trans.next()) { /* if its on an terminal add a shift entry */ sym = trans.on_symbol(); if (!sym.is_non_term()) { 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) { our_act_row.under_term[sym.index()] = act; } else { /* we now have at least one conflict */ production p = ((reduce_action)our_act_row.under_term[sym.index()]).reduce_with(); /* shift always wins */ if (!fix_with_precedence(p, sym.index(), our_act_row, act)) { our_act_row.under_term[sym.index()] = act; conflict_set.add(terminal.find(sym.index())); } } } else { /* for non terminals add an entry to the reduce-goto table */ our_red_row.under_non_term[sym.index()] = trans.to_state(); } } /* if we end up with conflict(s), report them */ if (!conflict_set.empty()) { report_conflicts(conflict_set); } }
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ /// <summary>Add (union) in a complete set. /// </summary> /// <param name="other">the set being added. /// </param> /// <returns>true if this changes the set. /// /// </returns> public virtual bool add(terminal_set other) { not_null(other); /* make a copy */ System.Collections.BitArray copy = (System.Collections.BitArray) _elements.Clone(); /* or in the other set */ //UPGRADE_NOTE: In .NET BitArrays must be of the same size to allow the 'System.Collections.BitArray.Or' operation. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1083"' _elements = _elements.Or(other._elements); /* changed if we are not the same as the copy */ //UPGRADE_TODO: method 'java.util.BitSet.equals' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilBitSetequals_javalangObject"' return !BitArraysEqual(_elements, copy); // _elements.Equals(copy); }
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ /// <summary>Constructor for cloning from another set. /// </summary> /// <param name="other">the set we are cloning from. /// /// </param> public terminal_set(terminal_set other) { not_null(other); _elements = (System.Collections.BitArray)other._elements.Clone(); }
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ /// <summary>Constructor with default position (dot at start). /// </summary> /// <param name="prod">the production for the item. /// </param> /// <param name="look">the set of lookahead symbols. /// /// </param> public lalr_item(production prod, terminal_set look) : this(prod, 0, look) { }
/*-----------------------------------------------------------*/ /*--- General Methods ---------------------------------------*/ /*-----------------------------------------------------------*/ /// <summary>Propagate incoming lookaheads through this item to others need to /// be changed. /// </summary> /// <param name="incoming">symbols to potentially be added to lookahead of this item. /// /// </param> public virtual void propagate_lookaheads(terminal_set incoming) { bool change = false; /* if we don't need to propagate, then bail out now */ if (!needs_propagation && (incoming == null || incoming.empty())) return ; /* if we have null incoming, treat as an empty set */ if (incoming != null) { /* add the incoming to the lookahead of this item */ change = lookahead().add(incoming); } /* if we changed or need it anyway, propagate across our links */ if (change || needs_propagation) { /* don't need to propagate again */ needs_propagation = false; /* propagate our lookahead into each item we are linked to */ for (int i = 0; i < propagate_items().Count; i++) ((lalr_item) (propagate_items().Peek(propagate_items().Count - (i + 1)))).propagate_lookaheads(lookahead()); } }
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ /// <summary>Fill in the parse table entries for this state. There are two /// parse tables that encode the viable prefix recognition machine, an /// action table and a reduce-goto table. The rows in each table /// correspond to states of the machine. The columns of the action table /// are indexed by terminal symbols and correspond to either transitions /// out of the state (shift entries) or reductions from the state to some /// previous state saved on the stack (reduce entries). All entries in the /// action table that are not shifts or reduces, represent errors. The /// reduce-goto table is indexed by non terminals and represents transitions /// out of a state on that non-terminal.<p> /// Conflicts occur if more than one action needs to go in one entry of the /// action table (this cannot happen with the reduce-goto table). Conflicts /// are resolved by always shifting for shift/reduce conflicts and choosing /// the lowest numbered production (hence the one that appeared first in /// the specification) in reduce/reduce conflicts. All conflicts are /// reported and if more conflicts are detected than were declared by the /// user, code generation is aborted. /// * /// </summary> /// <param name="act_table"> the action table to put entries in. /// </param> /// <param name="reduce_table">the reduce-goto table to put entries in. /// /// </param> public virtual void build_table_entries(parse_action_table act_table, parse_reduce_table reduce_table) { parse_action_row our_act_row; parse_reduce_row our_red_row; lalr_item itm; parse_action act, other_act; symbol sym; terminal_set conflict_set = new terminal_set(); /* pull out our rows from the tables */ our_act_row = act_table.under_state[index()]; our_red_row = reduce_table.under_state[index()]; /* consider each item in our state */ //UPGRADE_TODO: method 'java.util.Enumeration.hasMoreElements' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilEnumerationhasMoreElements"' for (System.Collections.IEnumerator i = items().all(); i.MoveNext(); ) { //UPGRADE_TODO: method 'java.util.Enumeration.nextElement' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilEnumerationnextElement"' itm = (lalr_item) i.Current; /* if its completed (dot at end) then reduce under the lookahead */ if (itm.dot_at_end()) { act = new reduce_action(itm.the_production()); /* consider each lookahead symbol */ for (int t = 0; t < terminal.number(); t++) { /* skip over the ones not in the lookahead */ if (!itm.lookahead().contains(t)) continue; /* if we don't already have an action put this one in */ if (our_act_row.under_term[t].kind() == parse_action.ERROR) { our_act_row.under_term[t] = act; } else { /* we now have at least one conflict */ terminal term = terminal.find(t); 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)) { /* if we have lower index hence priority, replace it*/ if (itm.the_production().index() < ((reduce_action) other_act).reduce_with().index()) { /* replace the action */ our_act_row.under_term[t] = act; } } else { /* Check precedences,see if problem is correctable */ if (fix_with_precedence(itm.the_production(), t, our_act_row, act)) { term = null; } } if (term != null) { conflict_set.add(term); } } } } } /* consider each outgoing transition */ for (lalr_transition trans = transitions(); trans != null; trans = trans.next()) { /* if its on an terminal add a shift entry */ sym = trans.on_symbol(); if (!sym.is_non_term()) { 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) { our_act_row.under_term[sym.index()] = act; } else { /* we now have at least one conflict */ production p = ((reduce_action) our_act_row.under_term[sym.index()]).reduce_with(); /* shift always wins */ if (!fix_with_precedence(p, sym.index(), our_act_row, act)) { our_act_row.under_term[sym.index()] = act; conflict_set.add(terminal.find(sym.index())); } } } else { /* for non terminals add an entry to the reduce-goto table */ our_red_row.under_non_term[sym.index()] = trans.to_state(); } } /* if we end up with conflict(s), report them */ if (!conflict_set.empty()) report_conflicts(conflict_set); }
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ /// <summary>Produce warning messages for all conflicts found in this state. /// </summary> protected internal virtual void report_conflicts(terminal_set conflict_set) { lalr_item itm, compare; //symbol shift_sym; bool after_itm; /* consider each element */ //UPGRADE_TODO: method 'java.util.Enumeration.hasMoreElements' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilEnumerationhasMoreElements"' for (System.Collections.IEnumerator itms = items().all(); itms.MoveNext(); ) { //UPGRADE_TODO: method 'java.util.Enumeration.nextElement' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilEnumerationnextElement"' itm = (lalr_item) itms.Current; /* clear the S/R conflict set for this item */ /* if it results in a reduce, it could be a conflict */ if (itm.dot_at_end()) { /* not yet after itm */ after_itm = false; /* compare this item against all others looking for conflicts */ //UPGRADE_TODO: method 'java.util.Enumeration.hasMoreElements' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilEnumerationhasMoreElements"' for (System.Collections.IEnumerator comps = items().all(); comps.MoveNext(); ) { //UPGRADE_TODO: method 'java.util.Enumeration.nextElement' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilEnumerationnextElement"' compare = (lalr_item) comps.Current; /* if this is the item, next one is after it */ if (itm == compare) after_itm = true; /* only look at it if its not the same item */ if (itm != compare) { /* is it a reduce */ if (compare.dot_at_end()) { /* only look at reduces after itm */ if (after_itm) if (compare.lookahead().intersects(itm.lookahead())) report_reduce_reduce(itm, compare); } } } /* report S/R conflicts under all the symbols we conflict under */ for (int t = 0; t < terminal.number(); t++) if (conflict_set.contains(t)) report_shift_reduce(itm, t); } } }
private void InitBlock() { _first_set = new terminal_set(); }