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; } }