public S4JState Clone()
{
S4JState item = (S4JState)this.MemberwiseClone();
item.AllowedStateTypes = this.AllowedStateTypes;
item.Gates = this.Gates.ToList();
item.FoundGates = null;
return(item);
}
private static S4JState GetStateBegin(char[] code, Int32 index, S4JStateBag StateBag, S4JToken prevToken)
{
if (prevToken == null)
{
return(null);
}
//foreach (S4JState state in StateBag.GetStates(prevToken.State.AllowedStatesNames))
{
// sprawdzamy rozpoczecie stanu
// if (prevToken == null /*||
// prevToken.State.IsAllowed(state)*///)
{
Boolean isAllowed = false;
List <S4JStateGate> matchedGates = new List <S4JStateGate>();
S4JState foundState = null;
// pobszukiwanie rozpoczecia stanu
var allowedStates = StateBag.GetAllowedStates(prevToken?.State);
//foreach (S4JState state in )
for (var i = 0; i < allowedStates.Length; i++)
{
var state = allowedStates[i];
Int32 gateStartCount = 0;
foreach (S4JStateGate gate in state.Gates)
{
if (S4JParserHelper.Is(code, index, gate.Start))
{
// jesli znaleziony ciag jest wiekszy od ostatniego
if (gateStartCount < gate.Start.Length && matchedGates.Count > 0)
{
matchedGates.Clear();
}
matchedGates.Add(gate.Clone());
isAllowed = true;
foundState = state;
gateStartCount = gate.Start.Length;
//break;
}
}
//if (isAllowed)
// break;
}
if (isAllowed)
{
S4JState newState = foundState.Clone();
newState.FoundGates = matchedGates;
return(newState);
}
}
}
/*foreach (S4JState state in StateBag)
* {
* // sprawdzamy rozpoczecie stanu
* if (prevToken == null ||
* prevToken.State.IsAllowed(state))
* {
* Boolean isAllowed = false;
* List<S4JStateGate> matchedGates = new List<S4JStateGate>();
*
* // pobszukiwanie rozpoczecia stanu
* foreach (S4JStateGate gate in state.Gates)
* {
* if (S4JParserHelper.Is(code, index, gate.Start))
* {
* matchedGates.Add(gate.Clone());
* isAllowed = true;
* }
* }
*
* if (isAllowed)
* {
* S4JState newState = state.Clone();
* newState.FoundGates = matchedGates;
* return newState;
* }
* }
* }*/
return(null);
}
private static IEnumerable <S4JStateStackEvent> Analyse(char[] code, int index, S4JStateBag StateBag, S4JTokenStack stateStack) // S4JStateStack stateStack)
{
// sprawdzamy zakończenie stanu
S4JToken prevToken = stateStack.Peek();
if (GetStateEnd(code, index, StateBag, prevToken) != null)
{
Int32 nextIndex = index + (prevToken.State.FoundGates.First().End == null ? 0 : (prevToken.State.FoundGates.First().End.Length - 1)) + 1;
yield return(new S4JStateStackEvent()
{
NewIndex = S4JParserHelper.SkipWhiteSpaces(code, nextIndex),
State = prevToken.State,
Popped = true,
// Chars = end
});
yield break;
}
prevToken = stateStack.Peek();
S4JState state = GetStateBegin(code, index, StateBag, prevToken);
if (state != null)
{
Int32 nextIndex = index + (state.FoundGates?.FirstOrDefault()?.Start == null ?
0 :
(state.FoundGates.First().Start.Length - 1)) + 1;
yield return(new S4JStateStackEvent()
{
// NewIndex = null,
NewIndex = state.IsQuotation ?
nextIndex :
// state.IsCollection ?
S4JParserHelper.SkipWhiteSpaces(code, nextIndex),
// index + (matchedGate?.Start == null ? 0 : (matchedGate.Start.Count - 1)) + 1,
State = state,
Pushed = true,
// Chars = matchedGate?.Start ?? new[] { code[index] }
});
}
else
{
Int32?newIndex = null;
// pominiecie białych znaków do nastepnego 'stanu'
// tylko jesli nie nie jestesmy w cytacie
if (!prevToken.State.IsQuotation &&
!prevToken.State.IsComment)
{
newIndex = S4JParserHelper.SkipWhiteSpaces(code, index + 1);
if (newIndex != null)
{
S4JState stateBegin = GetStateBegin(code, newIndex.Value, StateBag, prevToken);
S4JState stateEnd = GetStateEnd(code, newIndex.Value, StateBag, prevToken);
if (stateBegin != null || stateEnd != null)
{
newIndex = newIndex;
}
else
{
newIndex = null;
}
}
else
{
newIndex = Int32.MaxValue;
}
}
yield return(new S4JStateStackEvent()
{
NewIndex = newIndex,
State = stateStack.Peek()?.State,
Chars = new[] { code[index] }
});
}
}
////////////////////////////////
public bool IsAllowed(S4JState State)
{
return(IsAllowed(State.StateType));
}
public void Push(S4JState State)
{
this.Stack.Add(State);
this.History.Add(State);
}
