public void TestEncodeAndDecode(
[Values(
ParserActionKind.Fail,
ParserActionKind.Accept,
ParserActionKind.Reduce,
ParserActionKind.Shift
)]
ParserActionKind kind,
[Values(0, 1, 1024, ushort.MaxValue)]
int value1)
{
int cell = ParserAction.Encode(kind, value1);
var action = ParserAction.Decode(cell);
if (kind == ParserActionKind.Fail)
{
Assert.AreEqual(kind, action.Kind);
}
else
{
Assert.IsNotNull(action);
Assert.AreEqual(kind, action.Kind);
Assert.AreEqual(value1, action.Value1);
}
Assert.AreEqual(kind, ParserAction.GetKind(cell));
Assert.AreEqual(value1, ParserAction.GetId(cell));
}
private static ParserAction GetShift(LanguageData data, ParserAction x)
{
switch (x.Kind)
{
case ParserActionKind.Shift:
case ParserActionKind.ShiftReduce:
return(x);
case ParserActionKind.Conflict:
int start = x.Value1;
int count = x.Value2;
int last = start + count;
for (; start != last; ++start)
{
var cAction = ParserAction.Decode(data.ParserConflictActionTable[start]);
switch (cAction.Kind)
{
case ParserActionKind.Shift:
case ParserActionKind.ShiftReduce:
return(cAction);
}
}
break;
}
return(ParserAction.FailAction);
}
public void TestRMEncoding(
[Values(123, ParserAction.Value1Max, 0, 1)]
int value1,
[Values(123, 1, 2, ParserAction.Value2Max, 0, 1)]
short value2)
{
int cell = ParserAction.EncodeModifedReduce(value1, value2);
var output = ParserAction.Decode(cell);
Assert.IsNotNull(output);
Assert.AreEqual(ParserActionKind.Reduce, output.Kind);
Assert.AreEqual(value1, output.ProductionId);
Assert.AreEqual(value2, output.Size);
}
private IEnumerable <ParserAction> GetAllParserActions(int state, int token)
{
var cell = data.ParserActionTable.Get(state, token);
var action = ParserAction.Decode(cell);
if (action == null || action.Kind == ParserActionKind.Fail)
{
}
else if (action.Kind == ParserActionKind.Conflict)
{
for (int i = 0; i != action.Size; ++i)
{
yield return
(ParserAction.Decode(
data.ParserConflictActionTable[action.Value1 + i]));
}
}
else
{
yield return(action);
}
}
private static bool AreCompatibleStates(LanguageData data, int[] terms, ITable <int> table, int p, int q)
{
foreach (int term in terms)
{
var pCell = table.Get(p, term);
var qCell = table.Get(q, term);
var pAction = ParserAction.Decode(pCell);
var qAction = ParserAction.Decode(qCell);
if (pCell != qCell &&
!HaveSameShifts(data, pAction, qAction))
{
return(false);
}
if (pAction.Kind == ParserActionKind.Conflict ||
qAction.Kind == ParserActionKind.Conflict)
{
Console.WriteLine("Skipped conflicting {0}<->{1} states", p, q);
return(false);
}
if (!HaveComptibleReductions(data, pAction, qAction))
{
/*
* Console.WriteLine(
* "Skipped incompatible {0}<->{1} state reductions {2}<->{3}",
* p, q,
* pAction, qAction);
*/
return(false);
}
}
return(true);
}
internal void AddAction(int actionCell)
{
actions.Add(ParserAction.Decode(actionCell));
}