public void Equals_should_behave_as_expected(BracketExpression expression, object obj, bool expected, string reason)
{
// Act
bool actual = expression.Equals(obj);
// Assert
actual.Should()
.Be(expected, reason);
}
public void Complexity_should_behave_as_expected(BracketExpression expression, double expected)
{
// Act
double actual = expression.Complexity;
// Assert
actual.Should()
.Be(expected);
}
public void GetBracketExpression(string latex, IList <Element> container, Marker marker)
{
if (marker.Position < latex.Length - 13)
{
if (latex.Substring(marker.Position, 6) == "\\left(")
{
var n = 1;
var i = 0;
var j = marker.Position + 6;
while (j < latex.Length)
{
if (latex.Substring(j, 6) == "\\left(")
{
n += 1;
i += 6;
j += 6;
}
if (latex.Substring(j, 7) == "\\right)")
{
n -= 1;
i += 7;
j += 7;
}
else
{
i += 1;
j += 1;
}
if (n == 0)
{
break;
}
}
var t = latex.Substring(marker.Position + 6, i - 7);
var bracketExpression = new BracketExpression();
var mathematicsLine = new MathematicsLine();
mathematicsLine.Elements = ParseSubsection(t);
bracketExpression.InnerExpression = mathematicsLine;
container.Add(bracketExpression);
marker.Position += 6 + i;
}
}
}
/// <summary>
/// Перевірка виразу посимвольно через стек відкритих дужок
/// </summary>
/// <param name="letter">Символ</param>
/// <returns></returns>
private bool Check(char letter)
{
//Якщо це дужка ( чи [, то поміщуємо у стек
if (BracketExpression.IsOpenedBracket(letter))
{
_bracketExpressions.Push(ExpressionChecker.CreateExpression(letter));
return(true);
}
//Якщо дужка ) чи ], то видаляємо з стеку, також закриваємо вираз
if (BracketExpression.IsClosedBracket(letter))
{
var previous = _bracketExpressions.Peek();
var res = previous.Close(letter);
if (res)
{
_bracketExpressions.Pop();
}
return(res);
}
return(true);
}
public virtual TResult Visit(BracketExpression expression, TEnvironment environment)
{
expression.Expression.Accept(this, environment);
return(default(TResult));
}
public IValue Visit(BracketExpression expression, TypeEnvironment environment)
{
return(expression.Expression
.Accept(this, environment));
}
/// <summary>
/// Converts POSIX regular expression to .NET Framework regular expression
/// </summary>
/// <param name="expr">POSIX 1003.2 regular expression</param>
/// <returns>.NET Framework compatible regular expression</returns>
// WORKING: change to private!
public static string ConvertPosix2DotNetExpr(string expr)
{
if (expr == null) return "";
// number that is not used in automaton
const int errorState = 99;
// 0 == initial state
int state = 0;
// iterator for iterating in strings
#if !SILVERLIGHT
CharEnumerator ch = expr.GetEnumerator();
#else
System.Collections.Generic.IEnumerator<char> ch = new System.Collections.Generic.List<char>(expr.ToCharArray()).GetEnumerator();
#endif
// true if we are at the end of bracket expression
bool eOfExpr = false;
// true if we have read next character and this character is not applicable for current state,
// we change state with lambda step and there is character scanned again
// true if we are changing state and the character should be scanned again
bool lambdaStep = false;
// into this StringBuilder is converted regular expression written
// 2*expr.Length is estimated necessary length of output string
StringBuilder output = new StringBuilder(2 * expr.Length);
// bracket expressions are very complicated, we have made separate class for managing them
// if we need to create bracket expression class instance, we store it in this variable
// and reuse it after Reset() call
BracketExpression be = null;
eOfExpr = !ch.MoveNext();
while (!eOfExpr)
{
switch (state)
{
case 0: // initial state
switch (ch.Current)
{
case '\\':
state = 1;
break;
case '[':
state = 2;
if (be != null) // bracket expr. already exists, reset it only
be.Reset();
else
be = new BracketExpression();
break;
case '(':
state = 15;
break;
default:
output.Append(ch.Current);
break;
}
break;
case 1:
if (controlCharsMap.Contains(ch.Current))
{ // control character - must be preppended by '\'
output.Append('\\');
}
output.Append(ch.Current);
state = 0;
break;
case 2:
switch (ch.Current)
{
case '^':
be.Negation = true;
state = 3;
break;
case ']':
be.Append(']');
state = 4;
break;
default:
lambdaStep = true;
state = 4;
break;
}
break;
case 3:
if (ch.Current == ']')
be.Append(']');
else
lambdaStep = true;
state = 4;
break;
case 4:
switch (ch.Current)
{
case '[':
state = 5;
break;
case '\\':
be.StartNextPart();
be.Append('\\');
be.CurrentPartType = BracketExpression.PartType.NormalBackslash;
be.StartNextPart();
break;
case ']':
state = 0;
if (!be.WriteOut(ref output))
state = errorState;
break;
case '-':
be.CurrentPartType = BracketExpression.PartType.Range;
break;
default:
be.Append(ch.Current);
break;
}
break;
case 5:
switch (ch.Current)
{
case '.':
be.StartNextPart();
be.CurrentPartType = BracketExpression.PartType.CollatingElement;
state = 6;
break;
case ':':
be.StartNextPart();
be.CurrentPartType = BracketExpression.PartType.CharacterClass;
state = 7;
break;
case '=':
be.StartNextPart();
be.CurrentPartType = BracketExpression.PartType.EquivalenceClass;
state = 8;
break;
case '\\':
be.Append('\\', '\\');
state = 4;
break;
default:
be.Append('[', ch.Current);
state = 4;
break;
}
break;
case 6:
if (ch.Current == '\\')
be.Append('\\', '\\');
else
be.Append(ch.Current);
state = 9;
break;
case 7:
if (ch.Current == '\\')
be.Append('\\', '\\');
else
be.Append(ch.Current);
state = 10;
break;
case 8:
if (ch.Current == '\\')
be.Append('\\', '\\');
else
be.Append(ch.Current);
state = 11;
break;
case 9:
switch (ch.Current)
{
case '\\':
be.Append('\\', '\\');
break;
case '.':
state = 12;
break;
default:
be.Append(ch.Current);
break;
}
break;
case 10:
switch (ch.Current)
{
case '\\':
be.Append('\\', '\\');
break;
case ':':
state = 13;
break;
default:
be.Append(ch.Current);
break;
}
break;
case 11:
switch (ch.Current)
{
case '\\':
be.Append('\\', '\\');
break;
case '=':
state = 14;
break;
default:
be.Append(ch.Current);
break;
}
break;
case 12:
switch (ch.Current)
{
case ']':
be.StartNextPart();
state = 4;
break;
case '\\':
be.Append('.', '\\', '\\');
state = 9;
break;
default:
be.Append('.', ch.Current);
state = 9;
break;
}
break;
case 13:
switch (ch.Current)
{
case ']':
be.StartNextPart();
state = 4;
break;
case '\\':
be.Append(':', '\\', '\\');
state = 10;
break;
default:
be.Append(':', ch.Current);
state = 10;
break;
}
break;
case 14:
switch (ch.Current)
{
case ']':
be.StartNextPart();
state = 4;
break;
case '\\':
be.Append('=', '\\', '\\');
state = 11;
break;
default:
be.Append('=', ch.Current);
state = 11;
break;
}
break;
case 15:
switch (ch.Current)
{
case '?':
PhpException.Throw(PhpError.Warning, LibResources.GetString("question_mark_folowing_nothing"));
state = errorState;
break;
default:
output.Append('(');
output.Append(ch.Current);
state = 0;
break;
}
break;
default: // catch the ErrorState
eOfExpr = true;
output.Remove(0, output.Length);
break;
}
// we can eliminate this, but without lambda steps will be an automaton much more complicated
// other solution is calling ch.MoveNext() in each case statement, this would bring error liability
// but can save a few instructions in each iteration
if (!eOfExpr && !lambdaStep)
eOfExpr = !ch.MoveNext();
lambdaStep = false;
}
// check where an automaton has finished
switch (state)
{
case 0:
return output.ToString();
case 1:
PhpException.Throw(PhpError.Warning, LibResources.GetString("regexp_cannot_end_with_two_backslashes"));
return null;
case 15:
PhpException.Throw(PhpError.Warning, LibResources.GetString("regexp_cannot_end_with_open_bracket"));
return null;
default:
PhpException.Throw(PhpError.Warning, LibResources.GetString("unenclosed_bracket_expression"));
return null;
}
}
