/***************************************************************
* Function: in_dstates
**************************************************************/
private int in_dstates
(
CBunch bunch
)
{
CDfa dfa;
#if (OLD_DEBUG)
{
System.Console.Write("Looking for Set : ");
m_lexGen.print_set(bunch.m_nfa_set);
}
#endif
dfa = (CDfa)m_spec.m_dfa_sets[bunch.m_nfa_bit];
if (null != dfa)
{
#if (OLD_DUMP_DEBUG)
{
System.Console.WriteLine(" FOUND!");
}
#endif
return(dfa.m_label);
}
#if (OLD_DUMP_DEBUG)
{
System.Console.WriteLine(" NOT FOUND!");
}
#endif
return(NOT_IN_DSTATES);
}
/***************************************************************
* function: add_to_dstates
* Description: Takes as input a CBunch with details of
* a dfa state that needs to be created.
* 1) Allocates a new dfa state and saves it in
* the appropriate CSpec vector.
* 2) Initializes the fields of the dfa state
* with the information in the CBunch.
* 3) Returns index of new dfa.
**************************************************************/
private int add_to_dstates
(
CBunch bunch
)
{
CDfa dfa;
#if (DEBUG)
{
CUtility.ASSERT(null != bunch.m_nfa_set);
CUtility.ASSERT(null != bunch.m_nfa_bit);
CUtility.ASSERT(null != bunch.m_accept ||
CSpec.NONE == bunch.m_anchor);
}
#endif
/* Allocate, passing CSpec so dfa label can be Set. */
dfa = CAlloc.newCDfa(m_spec);
/* Initialize fields, including the mark field. */
dfa.m_nfa_set = (Vector)bunch.m_nfa_set.Clone();
dfa.m_nfa_bit = (SparseBitSet)bunch.m_nfa_bit.Clone();
dfa.m_accept = bunch.m_accept;
dfa.m_anchor = bunch.m_anchor;
dfa.m_mark = false;
/* Register dfa state using BitSet in CSpec Hashtable. */
m_spec.m_dfa_sets.Add(dfa.m_nfa_bit, dfa);
/*registerCDfa(dfa);*/
#if (OLD_DUMP_DEBUG)
{
System.Console.Write("Registering Set : ");
m_lexGen.print_set(dfa.m_nfa_set);
System.Console.WriteLine();
}
#endif
return(dfa.m_label);
}
/***************************************************************
* Function: make_dtrans
* Description: Creates uncompressed CDTrans transition table.
**************************************************************/
private void make_dtrans
(
)
/* throws java.lang.CloneNotSupportedException*/
{
//CDfa next;
CDfa dfa;
CBunch bunch;
int i;
int nextstate;
int size;
CDTrans dtrans;
CNfa nfa;
int istate;
int nstates;
if (m_spec.m_verbose)
{
System.Console.Write("Working on DFA states.");
}
/* Reference passing type and initializations. */
bunch = new CBunch();
m_unmarked_dfa = 0;
/* Allocate mapping array. */
nstates = m_spec.m_state_rules.Length;
m_spec.m_state_dtrans = new int[nstates];
for (istate = 0; nstates > istate; ++istate)
{
/* CSA bugfix: if we skip all zero size rules, then
* an specification with no rules produces an illegal
* lexer (0 states) instead of a lexer that rejects
* everything (1 nonaccepting state). [27-Jul-1999]
* if (0 == m_spec.m_state_rules[istate].size())
* {
* m_spec.m_state_dtrans[istate] = CDTrans.F;
* continue;
* }
*/
/* Create start state and initialize fields. */
//SI:testing
//bunch.m_nfa_set = (Vector) m_spec.m_state_rules[istate].Clone();
bunch.m_nfa_set = (Vector)((m_spec.m_state_rules[istate]).Clone());
sortStates(bunch.m_nfa_set);
bunch.m_nfa_bit = new SparseBitSet();
/* Initialize bit Set. */
size = bunch.m_nfa_set.size();
for (i = 0; size > i; ++i)
{
nfa = (CNfa)bunch.m_nfa_set.elementAt(i);
bunch.m_nfa_bit.Set(nfa.m_label);
}
bunch.m_accept = null;
bunch.m_anchor = CSpec.NONE;
bunch.m_accept_index = CUtility.INT_MAX;
e_closure(bunch);
add_to_dstates(bunch);
m_spec.m_state_dtrans[istate] = m_spec.m_dtrans_vector.size();
/* Main loop of CDTrans creation. */
while (null != (dfa = get_unmarked()))
{
if (m_spec.m_verbose)
{
System.Console.Write(".");
System.Console.Out.Flush();
}
#if (DEBUG)
{
CUtility.ASSERT(false == dfa.m_mark);
}
#endif
/* Get first unmarked node, then mark it. */
dfa.m_mark = true;
/* Allocate new CDTrans, then initialize fields. */
dtrans = new CDTrans(m_spec.m_dtrans_vector.size(), m_spec);
dtrans.m_accept = dfa.m_accept;
dtrans.m_anchor = dfa.m_anchor;
/* Set CDTrans array for each character transition. */
for (i = 0; i < m_spec.m_dtrans_ncols; ++i)
{
#if (DEBUG)
{
CUtility.ASSERT(0 <= i);
CUtility.ASSERT(m_spec.m_dtrans_ncols > i);
}
#endif
/* Create new dfa Set by attempting character transition. */
move(dfa.m_nfa_set, dfa.m_nfa_bit, i, bunch);
if (null != bunch.m_nfa_set)
{
e_closure(bunch);
}
#if (DEBUG)
{
CUtility.ASSERT((null == bunch.m_nfa_set &&
null == bunch.m_nfa_bit) ||
(null != bunch.m_nfa_set &&
null != bunch.m_nfa_bit));
}
#endif
/* Create new state or Set state to empty. */
if (null == bunch.m_nfa_set)
{
nextstate = CDTrans.F;
}
else
{
nextstate = in_dstates(bunch);
if (NOT_IN_DSTATES == nextstate)
{
nextstate = add_to_dstates(bunch);
}
}
#if (DEBUG)
{
CUtility.ASSERT(nextstate < m_spec.m_dfa_states.Count);
}
#endif
dtrans.m_dtrans[i] = nextstate;
}
#if (DEBUG)
{
CUtility.ASSERT(m_spec.m_dtrans_vector.size() == dfa.m_label);
}
#endif
m_spec.m_dtrans_vector.addElement(dtrans);
}
}
if (m_spec.m_verbose)
{
System.Console.WriteLine();
}
}
/***************************************************************
* Function: move
* Description: Returns null if resulting NFA Set is empty.
**************************************************************/
void move
(
Vector nfa_set,
SparseBitSet nfa_bit,
int b,
CBunch bunch
)
{
int size;
int index;
CNfa state;
bunch.m_nfa_set = null;
bunch.m_nfa_bit = null;
size = nfa_set.Count;
// System.Console.WriteLine(size);
for (index = 0; index < size; ++index)
{
state = (CNfa)nfa_set.elementAt(index);
// System.Console.WriteLine(index+" "+state.m_set);
if (b == state.m_edge ||
(CNfa.CCL == state.m_edge &&
state.m_set.contains(b)))
{
// System.Console.WriteLine(state.m_edge+" "+b);
if (null == bunch.m_nfa_set)
{
#if (DEBUG)
{
CUtility.ASSERT(null == bunch.m_nfa_bit);
}
#endif
bunch.m_nfa_set = new Vector();
/*bunch.m_nfa_bit
* = new SparseBitSet(m_spec.m_nfa_states.size());*/
bunch.m_nfa_bit = new SparseBitSet();
}
bunch.m_nfa_set.addElement(state.m_next);
/*System.Console.WriteLine("Size of bitset: " + bunch.m_nfa_bit.size());
* System.Console.WriteLine("Reference index: " + state.m_next.m_label);
* System.out.flush();*/
bunch.m_nfa_bit.Set(state.m_next.m_label);
}
}
if (null != bunch.m_nfa_set)
{
#if (DEBUG)
{
CUtility.ASSERT(null != bunch.m_nfa_bit);
}
#endif
sortStates(bunch.m_nfa_set);
}
return;
}
/***************************************************************
* Function: e_closure
* Description: Alters and returns input Set.
**************************************************************/
private void e_closure
(
CBunch bunch
)
{
Stack nfa_stack;
int size;
int i;
CNfa state;
/* Debug checks. */
#if (DEBUG)
{
CUtility.ASSERT(null != bunch);
CUtility.ASSERT(null != bunch.m_nfa_set);
CUtility.ASSERT(null != bunch.m_nfa_bit);
}
#endif
bunch.m_accept = null;
bunch.m_anchor = CSpec.NONE;
bunch.m_accept_index = CUtility.INT_MAX;
/* Create initial stack. */
nfa_stack = new Stack();
size = bunch.m_nfa_set.size();
for (i = 0; i < size; ++i)
{
state = (CNfa)bunch.m_nfa_set.elementAt(i);
#if (DEBUG)
{
CUtility.ASSERT(bunch.m_nfa_bit.Get(state.m_label));
}
#endif
nfa_stack.Push(state);
}
/* Main loop. */
//while (false == nfa_stack.empty())
while (nfa_stack.Count > 0)
{
state = (CNfa)nfa_stack.Pop();
#if (OLD_DUMP_DEBUG)
{
if (null != state.m_accept)
{
System.Console.WriteLine("Looking at accepting state " + state.m_label
+ " with <"
+ (new string(state.m_accept.m_action, 0,
state.m_accept.m_action_read))
+ ">");
}
}
#endif
if (null != state.m_accept &&
state.m_label < bunch.m_accept_index)
{
bunch.m_accept_index = state.m_label;
bunch.m_accept = state.m_accept;
bunch.m_anchor = state.m_anchor;
#if (OLD_DUMP_DEBUG)
{
System.Console.WriteLine("Found accepting state " + state.m_label
+ " with <"
+ (new string(state.m_accept.m_action, 0,
state.m_accept.m_action_read))
+ ">");
}
#endif
#if (DEBUG)
{
CUtility.ASSERT(null != bunch.m_accept);
CUtility.ASSERT(CSpec.NONE == bunch.m_anchor ||
0 != (bunch.m_anchor & CSpec.END) ||
0 != (bunch.m_anchor & CSpec.START));
}
#endif
}
if (CNfa.EPSILON == state.m_edge)
{
if (null != state.m_next)
{
if (false == bunch.m_nfa_set.contains(state.m_next))
{
#if (DEBUG)
{
CUtility.ASSERT(false == bunch.m_nfa_bit.Get(state.m_next.m_label));
}
#endif
bunch.m_nfa_bit.Set(state.m_next.m_label);
bunch.m_nfa_set.addElement(state.m_next);
nfa_stack.Push(state.m_next);
}
}
if (null != state.m_next2)
{
if (false == bunch.m_nfa_set.contains(state.m_next2))
{
#if (DEBUG)
{
CUtility.ASSERT(false == bunch.m_nfa_bit.Get(state.m_next2.m_label));
}
#endif
bunch.m_nfa_bit.Set(state.m_next2.m_label);
bunch.m_nfa_set.addElement(state.m_next2);
nfa_stack.Push(state.m_next2);
}
}
}
}
if (null != bunch.m_nfa_set)
{
sortStates(bunch.m_nfa_set);
}
return;
}