|
package java_cup;
|
|
import java.util.Enumeration;
|
import java.util.Hashtable;
|
import java.util.Stack;
|
|
/** This class represents a state in the LALR viable prefix recognition machine.
|
* A state consists of an LALR item set and a set of transitions to other
|
* states under terminal and non-terminal symbols. Each state represents
|
* a potential configuration of the parser. If the item set of a state
|
* includes an item such as: <pre>
|
* [A ::= B * C d E , {a,b,c}]
|
* </pre>
|
* this indicates that when the parser is in this state it is currently
|
* looking for an A of the given form, has already seen the B, and would
|
* expect to see an a, b, or c after this sequence is complete. Note that
|
* the parser is normally looking for several things at once (represented
|
* by several items). In our example above, the state would also include
|
* items such as: <pre>
|
* [C ::= * X e Z, {d}]
|
* [X ::= * f, {e}]
|
* </pre>
|
* to indicate that it was currently looking for a C followed by a d (which
|
* would be reduced into a C, matching the first symbol in our production
|
* above), and the terminal f followed by e.<p>
|
*
|
* At runtime, the parser uses a viable prefix recognition machine made up
|
* of these states to parse. The parser has two operations, shift and reduce.
|
* In a shift, it consumes one token and makes a transition to a new state.
|
* This corresponds to "moving the dot past" a terminal in one or more items
|
* in the state (these new shifted items will then be found in the state at
|
* the end of the transition). For a reduce operation, the parser is
|
* signifying that it is recognizing the RHS of some production. To do this
|
* it first "backs up" by popping a stack of previously saved states. It
|
* pops off the same number of states as are found in the RHS of the
|
* production. This leaves the machine in the same state is was in when the
|
* parser first attempted to find the RHS. From this state it makes a
|
* transition based on the non-terminal on the LHS of the production. This
|
* corresponds to placing the parse in a configuration equivalent to having
|
* replaced all the symbols from the the input corresponding to the RHS with
|
* the symbol on the LHS.
|
*
|
* @see java_cup.lalr_item
|
* @see java_cup.lalr_item_set
|
* @see java_cup.lalr_transition
|
* @version last updated: 11/25/95
|
* @author Scott Hudson
|
*
|
*/
|
|
public class lalr_state {
|
/*-----------------------------------------------------------*/
|
/*--- Constructor(s) ----------------------------------------*/
|
/*-----------------------------------------------------------*/
|
|
/** Constructor for building a state from a set of items.
|
* @param itms the set of items that makes up this state.
|
*/
|
public lalr_state(lalr_item_set itms) throws internal_error
|
{
|
/* don't allow null or duplicate item sets */
|
if (itms == null)
|
throw new internal_error(
|
"Attempt to construct an LALR state from a null item set");
|
|
if (find_state(itms) != null)
|
throw new internal_error(
|
"Attempt to construct a duplicate LALR state");
|
|
/* assign a unique index */
|
_index = next_index++;
|
|
/* store the items */
|
_items = itms;
|
|
/* add to the global collection, keyed with its item set */
|
_all.put(_items,this);
|
}
|
|
/*-----------------------------------------------------------*/
|
/*--- (Access to) Static (Class) Variables ------------------*/
|
/*-----------------------------------------------------------*/
|
|
/** Collection of all states. */
|
protected static Hashtable _all = new Hashtable();
|
|
/** Collection of all states. */
|
public static Enumeration all() {return _all.elements();}
|
|
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
|
|
/** Indicate total number of states there are. */
|
public static int number() {return _all.size();}
|
|
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
|
|
/** Hash table to find states by their kernels (i.e, the original,
|
* unclosed, set of items -- which uniquely define the state). This table
|
* stores state objects using (a copy of) their kernel item sets as keys.
|
*/
|
protected static Hashtable _all_kernels = new Hashtable();
|
|
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
|
|
/** Find and return state with a given a kernel item set (or null if not
|
* found). The kernel item set is the subset of items that were used to
|
* originally create the state. These items are formed by "shifting the
|
* dot" within items of other states that have a transition to this one.
|
* The remaining elements of this state's item set are added during closure.
|
* @param itms the kernel set of the state we are looking for.
|
*/
|
public static lalr_state find_state(lalr_item_set itms)
|
{
|
if (itms == null)
|
return null;
|
else
|
return (lalr_state)_all.get(itms);
|
}
|
|
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
|
|
/** Static counter for assigning unique state indexes. */
|
protected static int next_index = 0;
|
|
/*-----------------------------------------------------------*/
|
/*--- (Access to) Instance Variables ------------------------*/
|
/*-----------------------------------------------------------*/
|
|
/** The item set for this state. */
|
protected lalr_item_set _items;
|
|
/** The item set for this state. */
|
public lalr_item_set items() {return _items;}
|
|
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
|
|
/** List of transitions out of this state. */
|
protected lalr_transition _transitions = null;
|
|
/** List of transitions out of this state. */
|
public lalr_transition transitions() {return _transitions;}
|
|
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
|
|
/** Index of this state in the parse tables */
|
protected int _index;
|
|
/** Index of this state in the parse tables */
|
public int index() {return _index;}
|
|
/*-----------------------------------------------------------*/
|
/*--- Static Methods ----------------------------------------*/
|
/*-----------------------------------------------------------*/
|
|
/** Helper routine for debugging -- produces a dump of the given state
|
* onto System.out.
|
*/
|
protected static void dump_state(lalr_state st) throws internal_error
|
{
|
lalr_item_set itms;
|
lalr_item itm;
|
production_part part;
|
|
if (st == null)
|
{
|
System.out.println("NULL lalr_state");
|
return;
|
}
|
|
System.out.println("lalr_state [" + st.index() + "] {");
|
itms = st.items();
|
for (Enumeration e = itms.all(); e.hasMoreElements(); )
|
{
|
itm = (lalr_item)e.nextElement();
|
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("(*) ");
|
part = itm.the_production().rhs(i);
|
if (part.is_action())
|
System.out.print("{action} ");
|
else
|
System.out.print(((symbol_part)part).the_symbol().name() + " ");
|
}
|
if (itm.dot_at_end()) System.out.print("(*) ");
|
System.out.println("]");
|
}
|
System.out.println("}");
|
}
|
|
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
|
|
/** Propagate lookahead sets through the constructed viable prefix
|
* recognizer. When the machine is constructed, each item that results
|
in the creation of another such that its lookahead is included in the
|
other's will have a propagate link set up for it. This allows additions
|
to the lookahead of one item to be included in other items that it
|
was used to directly or indirectly create.
|
*/
|
protected static void propagate_all_lookaheads() throws internal_error
|
{
|
/* iterate across all states */
|
for (Enumeration st = all(); st.hasMoreElements(); )
|
{
|
/* propagate lookaheads out of that state */
|
((lalr_state)st.nextElement()).propagate_lookaheads();
|
}
|
}
|
|
/*-----------------------------------------------------------*/
|
/*--- General Methods ---------------------------------------*/
|
/*-----------------------------------------------------------*/
|
|
/** Add a transition out of this state to another.
|
* @param on_sym the symbol the transition is under.
|
* @param to_st the state the transition goes to.
|
*/
|
public void add_transition(symbol on_sym, lalr_state to_st)
|
throws internal_error
|
{
|
lalr_transition trans;
|
|
/* create a new transition object and put it in our list */
|
trans = new lalr_transition(on_sym, to_st, _transitions);
|
_transitions = trans;
|
}
|
|
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
|
|
/** Build an LALR viable prefix recognition machine given a start
|
* production. This method operates by first building a start state
|
* from the start production (based on a single item with the dot at
|
* the beginning and EOF as expected lookahead). Then for each state
|
* it attempts to extend the machine by creating transitions out of
|
* the state to new or existing states. When considering extension
|
* from a state we make a transition on each symbol that appears before
|
* the dot in some item. For example, if we have the items: <pre>
|
* [A ::= a b * X c, {d,e}]
|
* [B ::= a b * X d, {a,b}]
|
* </pre>
|
* in some state, then we would be making a transition under X to a new
|
* state. This new state would be formed by a "kernel" of items
|
* corresponding to moving the dot past the X. In this case: <pre>
|
* [A ::= a b X * c, {d,e}]
|
* [B ::= a b X * Y, {a,b}]
|
* </pre>
|
* The full state would then be formed by "closing" this kernel set of
|
* items so that it included items that represented productions of things
|
* the parser was now looking for. In this case we would items
|
* corresponding to productions of Y, since various forms of Y are expected
|
* next when in this state (see lalr_item_set.compute_closure() for details
|
* on closure). <p>
|
*
|
* The process of building the viable prefix recognizer terminates when no
|
* new states can be added. However, in order to build a smaller number of
|
* states (i.e., corresponding to LALR rather than canonical LR) the state
|
* building process does not maintain full loookaheads in all items.
|
* Consequently, after the machine is built, we go back and propagate
|
* lookaheads through the constructed machine using a call to
|
* propagate_all_lookaheads(). This makes use of propagation links
|
* constructed during the closure and transition process.
|
*
|
* @param start_prod the start production of the grammar
|
* @see java_cup.lalr_item_set#compute_closure
|
* @see java_cup.lalr_state#propagate_all_lookaheads
|
*/
|
|
public static lalr_state build_machine(production start_prod)
|
throws internal_error
|
{
|
lalr_state start_state;
|
lalr_item_set start_items;
|
lalr_item_set new_items;
|
lalr_item_set linked_items;
|
lalr_item_set kernel;
|
Stack work_stack = new Stack();
|
lalr_state st, new_st;
|
symbol_set outgoing;
|
lalr_item itm, new_itm, existing, fix_itm;
|
symbol sym, sym2;
|
Enumeration i, s, fix;
|
|
/* sanity check */
|
if (start_prod == null)
|
throw new internal_error(
|
"Attempt to build viable prefix recognizer using a null production");
|
|
/* build item with dot at front of start production and EOF lookahead */
|
start_items = new lalr_item_set();
|
itm = new lalr_item(start_prod);
|
itm.lookahead().add(terminal.EOF);
|
start_items.add(itm);
|
|
/* create copy the item set to form the kernel */
|
kernel = new lalr_item_set(start_items);
|
|
/* create the closure from that item set */
|
start_items.compute_closure();
|
|
/* build a state out of that item set and put it in our work set */
|
start_state = new lalr_state(start_items);
|
work_stack.push(start_state);
|
|
/* enter the state using the kernel as the key */
|
_all_kernels.put(kernel, start_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 */
|
st = (lalr_state)work_stack.pop();
|
|
/* gather up all the symbols that appear before dots */
|
outgoing = new symbol_set();
|
for (i = st.items().all(); i.hasMoreElements(); )
|
{
|
itm = (lalr_item)i.nextElement();
|
|
/* add the symbol before the dot (if any) to our collection */
|
sym = itm.symbol_after_dot();
|
if (sym != null) outgoing.add(sym);
|
}
|
|
/* now create a transition out for each individual symbol */
|
for (s = outgoing.all(); s.hasMoreElements(); )
|
{
|
sym = (symbol)s.nextElement();
|
|
/* will be keeping the set of items with propagate links */
|
linked_items = new lalr_item_set();
|
|
/* gather up shifted versions of all the items that have this
|
symbol before the dot */
|
new_items = new lalr_item_set();
|
for (i = st.items().all(); i.hasMoreElements();)
|
{
|
itm = (lalr_item)i.nextElement();
|
|
/* if this is the symbol we are working on now, add to set */
|
sym2 = itm.symbol_after_dot();
|
if (sym.equals(sym2))
|
{
|
/* add to the kernel of the new state */
|
new_items.add(itm.shift());
|
|
/* remember that itm has propagate link to it */
|
linked_items.add(itm);
|
}
|
}
|
|
/* use new items as state kernel */
|
kernel = new lalr_item_set(new_items);
|
|
/* have we seen this one already? */
|
new_st = (lalr_state)_all_kernels.get(kernel);
|
|
/* if we haven't, build a new state out of the item set */
|
if (new_st == null)
|
{
|
/* compute closure of the kernel for the full item set */
|
new_items.compute_closure();
|
|
/* build the new state */
|
new_st = new lalr_state(new_items);
|
|
/* add the new state to our work set */
|
work_stack.push(new_st);
|
|
/* put it in our kernel table */
|
_all_kernels.put(kernel, new_st);
|
}
|
/* otherwise relink propagation to items in existing state */
|
else
|
{
|
/* walk through the items that have links to the new state */
|
for (fix = linked_items.all(); fix.hasMoreElements(); )
|
{
|
fix_itm = (lalr_item)fix.nextElement();
|
|
/* look at each propagate link out of that item */
|
for (int l =0; l < fix_itm.propagate_items().size(); l++)
|
{
|
/* pull out item linked to in the new state */
|
new_itm =
|
(lalr_item)fix_itm.propagate_items().elementAt(l);
|
|
/* find corresponding item in the existing state */
|
existing = new_st.items().find(new_itm);
|
|
/* fix up the item so it points to the existing set */
|
if (existing != null)
|
fix_itm.propagate_items().setElementAt(existing ,l);
|
}
|
}
|
}
|
|
/* add a transition from current state to that state */
|
st.add_transition(sym, new_st);
|
}
|
}
|
|
/* all done building states */
|
|
/* propagate complete lookahead sets throughout the states */
|
propagate_all_lookaheads();
|
|
return start_state;
|
}
|
|
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
|
|
/** Propagate lookahead sets out of this state. This recursively
|
* propagates to all items that have propagation links from some item
|
* in this state.
|
*/
|
protected void propagate_lookaheads() throws internal_error
|
{
|
/* recursively propagate out from each item in the state */
|
for (Enumeration itm = items().all(); itm.hasMoreElements(); )
|
((lalr_item)itm.nextElement()).propagate_lookaheads(null);
|
}
|
|
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
|
|
/** 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.
|
*
|
* @param act_table the action table to put entries in.
|
* @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
|
{
|
parse_action_row our_act_row;
|
parse_reduce_row our_red_row;
|
lalr_item itm;
|
parse_action act, other_act;
|
symbol sym;
|
boolean conflicted = false;
|
|
/* 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 */
|
for (Enumeration i = items().all(); i.hasMoreElements(); )
|
{
|
itm = (lalr_item)i.nextElement();
|
|
/* 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 */
|
conflicted = true;
|
|
other_act = our_act_row.under_term[t];
|
|
/* if the other act was not a shift */
|
if (other_act.kind() != parse_action.SHIFT)
|
{
|
/* 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;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
/* 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 */
|
conflicted = true;
|
|
/* shift always wins */
|
our_act_row.under_term[sym.index()] = act;
|
}
|
}
|
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 (conflicted)
|
report_conflicts();
|
}
|
|
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
|
|
/** Produce warning messages for all conflicts found in this state. */
|
protected void report_conflicts()
|
throws internal_error
|
{
|
lalr_item itm, compare;
|
symbol shift_sym;
|
terminal_set conflict_set;
|
boolean after_itm;
|
|
/* consider each element */
|
for (Enumeration itms = items().all(); itms.hasMoreElements(); )
|
{
|
itm = (lalr_item)itms.nextElement();
|
|
/* clear the S/R conflict set for this item */
|
conflict_set = new terminal_set();
|
|
/* 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 */
|
for (Enumeration comps = items().all(); comps.hasMoreElements(); )
|
{
|
compare = (lalr_item)comps.nextElement();
|
|
/* 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)
|
/* does the comparison item conflict? */
|
if (compare.lookahead().intersects(itm.lookahead()))
|
/* report a reduce/reduce conflict */
|
report_reduce_reduce(itm, compare);
|
}
|
/* must be a shift on a terminal or non-terminal */
|
else
|
{
|
/* is it a shift on a terminal */
|
shift_sym = compare.symbol_after_dot();
|
if (!shift_sym.is_non_term())
|
{
|
/* does the terminal conflict with our item */
|
if (itm.lookahead().contains((terminal)shift_sym))
|
/* remember the terminal symbol in conflict */
|
conflict_set.add((terminal)shift_sym);
|
}
|
}
|
}
|
}
|
/* 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);
|
}
|
}
|
}
|
|
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
|
|
/** Produce a warning message for one reduce/reduce conflict.
|
*
|
* @param itm1 first item in conflict.
|
* @param itm2 second item in conflict.
|
*/
|
protected void report_reduce_reduce(lalr_item itm1, lalr_item itm2)
|
throws internal_error
|
{
|
boolean comma_flag = false;
|
|
System.err.println("*** Reduce/Reduce conflict found in state #"+index());
|
System.err.print (" between ");
|
System.err.println(itm1.to_simple_string());
|
System.err.print (" and ");
|
System.err.println(itm2.to_simple_string());
|
System.err.print(" under symbols: {" );
|
for (int t = 0; t < terminal.number(); t++)
|
{
|
if (itm1.lookahead().contains(t) && itm2.lookahead().contains(t))
|
{
|
if (comma_flag) System.err.print(", "); else comma_flag = true;
|
System.err.print(terminal.find(t).name());
|
}
|
}
|
System.err.println("}");
|
System.err.print(" Resolved in favor of ");
|
if (itm1.the_production().index() < itm2.the_production().index())
|
System.err.println("the first production.\n");
|
else
|
System.err.println("the second production.\n");
|
|
/* count the conflict */
|
emit.num_conflicts++;
|
lexer.warning_count++;
|
}
|
|
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
|
|
/** Produce a warning message for one shift/reduce conflict.
|
*
|
* @param red_itm the item with the reduce.
|
* @param conflict_sym the index of the symbol conflict occurs under.
|
*/
|
protected void report_shift_reduce(
|
lalr_item red_itm,
|
int conflict_sym)
|
throws internal_error
|
{
|
lalr_item itm;
|
symbol shift_sym;
|
|
/* emit top part of message including the reduce item */
|
System.err.println("*** Shift/Reduce conflict found in state #"+index());
|
System.err.print (" between ");
|
System.err.println(red_itm.to_simple_string());
|
|
/* find and report on all items that shift under our conflict symbol */
|
for (Enumeration itms = items().all(); itms.hasMoreElements(); )
|
{
|
itm = (lalr_item)itms.nextElement();
|
|
/* only look if its not the same item and not a reduce */
|
if (itm != red_itm && !itm.dot_at_end())
|
{
|
/* is it a shift on our conflicting terminal */
|
shift_sym = itm.symbol_after_dot();
|
if (!shift_sym.is_non_term() && shift_sym.index() == conflict_sym)
|
{
|
/* yes, report on it */
|
System.err.println(" and " + itm.to_simple_string());
|
}
|
}
|
}
|
System.err.println(" under symbol "+ terminal.find(conflict_sym).name());
|
System.err.println(" Resolved in favor of shifting.\n");
|
|
/* count the conflict */
|
emit.num_conflicts++;
|
lexer.warning_count++;
|
}
|
|
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
|
|
/** Equality comparison. */
|
public boolean equals(lalr_state other)
|
{
|
/* we are equal if our item sets are equal */
|
return other != null && items().equals(other.items());
|
}
|
|
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
|
|
/** Generic equality comparison. */
|
public boolean equals(Object other)
|
{
|
if (!(other instanceof lalr_state))
|
return false;
|
else
|
return equals((lalr_state)other);
|
}
|
|
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
|
|
/** Produce a hash code. */
|
public int hashCode()
|
{
|
/* just use the item set hash code */
|
return items().hashCode();
|
}
|
|
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
|
|
/** Convert to a string. */
|
public String toString()
|
{
|
String result;
|
lalr_transition tr;
|
|
/* dump the item set */
|
result = "lalr_state [" + index() + "]: " + _items + "\n";
|
|
/* do the transitions */
|
for (tr = transitions(); tr != null; tr = tr.next())
|
{
|
result += tr;
|
result += "\n";
|
}
|
|
return result;
|
}
|
|
/*-----------------------------------------------------------*/
|
};
|
