private static int IndexOf(List <LALRState> state, LALRState item)
{
for (int x = 0; x < state.Count; x++)
{
if (state[x].Has(item))
{
return(x);
}
}
return(-1);
}
private List <LALRState> CreateLALRState(CachedGrammar cg)
{
List <LALRState> clr = CreateCLRState(cg);
List <LALRState> lalr = new List <LALRState>();
int cnt = clr.Count;
for (int x = 0; x < cnt; x++)
{
LALRState current_state = clr[x];
for (int z = x + 1; z < cnt;)
{
LinkedHashSet <LRxItem> xlist = current_state.items;
LinkedHashSet <LRxItem> zlist = clr[z].items;
IEqualityComparer <LRxItem> save = xlist.Comparer;
xlist.Comparer = LRxItemComparerSlim.Instance;
zlist.Comparer = LRxItemComparerSlim.Instance;
if (xlist.SetEquals(zlist))
{
IEnumerator <LRxItem> e1 = xlist.GetEnumerator();
while (e1.MoveNext())
{
LRxItem now = e1.Current;
IEnumerator <LRxItem> e2 = zlist.GetEnumerator();
while (e2.MoveNext())
{
if (now.CoreEquals(e2.Current))
{
now.lookahead.UnionWith(e2.Current.lookahead);
break;
}
}
e2.Dispose();
}
e1.Dispose();
xlist.Comparer = save;
zlist.Comparer = save;
for (int a = 0; a < cnt; a++)
{
Map <LALRState> map = clr[a].map;
KeyValuePair <int, LALRState>[] kvs = map.ToArray();
for (int b = 0, bm = kvs.Length; b < bm; b++)
{
if (kvs[b].Value.items.SetEquals(zlist))
{
map.Add(kvs[b].Key, current_state);
}
}
}
clr.RemoveAt(z);
cnt--;
}
else
{
xlist.Comparer = save;
zlist.Comparer = save;
z++;
}
}
lalr.Add(current_state);
}
clr.Clear();
return(lalr);
}
private Map <TableItem>[] CreateATB(List <LALRState> state)
{
Grammar g = m_grammar;
int cnt = state.Count;
int stnon = g.startIdx.ToNonterminal();
Map <TableItem>[] res = new Map <TableItem> [cnt];
int x = 0;
for (; x < cnt; x++)
{
Map <TableItem> item = new Map <TableItem>();
IEnumerator <KeyValuePair <int, LALRState> > e1 = state[x].map.GetEnumerator();
while (e1.MoveNext())
{
if (e1.Current.Key.IsTerminal())
{
item.Add(e1.Current.Key, new TableItem(act_SHIFT, IndexOf(state, e1.Current.Value)));
}
}
e1.Dispose();
res[x] = item;
}
for (x = 0; x < cnt; x++)
{
IEnumerator <LRxItem> e1 = state[x].items.GetEnumerator();
Map <TableItem> ctb = res[x];
while (e1.MoveNext())
{
LRxItem cit = e1.Current;
if (cit.IsEnd)
{
if (cit.produce == stnon)
{
ctb.Add(ExpressInt.end_symbol, new TableItem(act_ACCEPT, 0));
}
else
{
int index = IndexOf(g, cit);
TableItem reduce = new TableItem(act_REDUCE, index);
IEnumerator <int> e2 = cit.lookahead.GetEnumerator();
while (e2.MoveNext())
{
if (ctb.Contains(e2.Current))
{
#if DEBUG
LALRState current_state = state[x];
TokenType debug_tok = (TokenType)e2.Current;
#endif
m_handler.Fail($"SHIFT-REDUCE CONFILCT -> state: {x}");
}
else
{
ctb.Add(e2.Current, reduce);
}
}
e2.Dispose();
}
}
}
e1.Dispose();
}
return(res);
}
private List <LALRState> CreateCLRState(CachedGrammar cg)
{
LALRState now = new LALRState(new LRxItem(cg.m_value.StartItem, new CHashSet <int> {
ExpressInt.end_symbol
}));
LR1Helper.Closure(cg, now.items);
List <LALRState> list = new List <LALRState> {
now
};
for (int x = 0; x < list.Count; x++)
{
now = list[x];
IForwardIterator <LRxItem> iter = now.items.Begin();
IForwardIterator <LRxItem> e1 = now.items.Begin();
do
{
if (iter.Value.IsEnd)
{
continue;
}
LinkedHashSet <LRxItem> nextit = new LinkedHashSet <LRxItem>();
int ms = iter.Value.MarkSymbol;
do
{
if (e1.Value.MarkSymbol == ms)
{
nextit.Add(e1.Value.GetNext());
}
} while (e1.LazyAdd());
e1.Reset();
LR1Helper.Closure(cg, nextit);
bool exist = false;
for (int z = 0; z < list.Count; z++)
{
if (list[z].items.SetEquals(nextit))
{
exist = true;
now.map.Add(ms, list[z]);
}
}
if (!exist)
{
LALRState next = new LALRState(nextit);
list.Add(next);
now.map.Add(ms, next);
}
} while (iter.LazyAdd());
iter.Dispose();
e1.Dispose();
}
return(list);
}
