public static void Main(string[] args) { SequenceParser.WarningMessage(); var stack = new Stack <int>(); for (int i = 0; i < 200; i++) { stack.Push(i); } Console.WriteLine(new string('=', 60)); Console.WriteLine("PUSHING to stack"); foreach (var st in stack) { Console.Write($"{st} "); } Console.WriteLine(new string('=', 60)); Console.WriteLine("POPING from stack"); for (var i = 0; i < 200; i++) { Console.Write($"{stack.Pop()} "); } }
public override Parser <TInput> VisitSequence(SequenceParser <TInput> parser) { if (state.LastResult < 0) { // last parser failed, so fail the whole rule state.InputLength = -state.InputLength + state.LastResult; output.SetCount(state.OriginalOutputCount); return(null); } else { state.InputLength += state.LastResult; if (state.State >= parser.Parsers.Count) { return(null); } else { var next = parser.Parsers[state.State]; state.State++; state.NextOutputStart = output.Count; return(next); } } }
// Write a program that reads N integers from the console and reverses them using a stack. // Use the Stack<int> class. public static void Main(string[] args) { SequenceParser.WarningMessage(); Console.WriteLine("Task 2 : Enter Interegers (like: '1 2 3' or '1,2,3') to stack and reverse"); var digits = SequenceParser.StringNumberSequenceToList(Console.ReadLine()); Stack <int> stack = new Stack <int>(); foreach (var item in digits) { stack.Push(item); } Console.WriteLine("Stack BEFORE reversal :"); foreach (var item in stack) { Console.Write(item); } Console.WriteLine(); ReverseStackRecursive(stack); Console.WriteLine("Stack AFTER reversal :"); while (stack.Count > 0) { Console.Write(stack.Pop()); } Console.WriteLine(); }
[InlineData('\v', ConsoleBuffer.Commands.ControlCharacter.ControlCode.LF)] // lmao vertical tabs public void ControlCharacters(char c, ConsoleBuffer.Commands.ControlCharacter.ControlCode code) { var parser = new SequenceParser(); Assert.Equal(ParserAppendResult.Complete, parser.Append(c)); Assert.IsType <ConsoleBuffer.Commands.ControlCharacter>(parser.Command); Assert.Equal(code, (parser.Command as ConsoleBuffer.Commands.ControlCharacter).Code); }
[DataRow('\v', ConsoleBuffer.Commands.ControlCharacter.ControlCode.LF)] // lmao vertical tabs public void ControlCharacters(char c, ConsoleBuffer.Commands.ControlCharacter.ControlCode code) { var parser = new SequenceParser(); Assert.AreEqual(ParserAppendResult.Complete, parser.Append(c)); Assert.IsInstanceOfType(parser.Command, typeof(ConsoleBuffer.Commands.ControlCharacter)); Assert.AreEqual(code, (parser.Command as ConsoleBuffer.Commands.ControlCharacter).Code); }
public void Basic() { var parser = new SequenceParser(); foreach (var c in "hello world") { Assert.AreEqual(ParserAppendResult.Render, parser.Append(c)); } }
private static void BuildDocumentation(string content, List <string> matches, string schemaName) { PGSchema schema = SchemaProcessor.GetSchema(schemaName); content = content.Replace("[DBName]", Program.Database.ToUpperInvariant()); content = content.Replace("[SchemaName]", schemaName); content = SequenceParser.Parse(content, matches, SequenceProcessor.GetSequences(schemaName)); content = TableParser.Parse(content, matches, schema.Tables); content = ViewParser.Parse(content, matches, schema.Views); content = SequenceParser.Parse(content, matches, schema.Sequences); content = MaterializedViewParser.Parse(content, matches, schema.MaterializedViews); content = FunctionParser.Parse(content, matches, schema.Functions); content = FunctionParser.ParseTriggers(content, matches, schema.TriggerFunctions); content = TypeParser.Parse(content, matches, schema.Types); foreach (PgTable table in schema.Tables) { Console.WriteLine("Generating documentation for table \"{0}\".", table.Name); TableRunner.Run(table); } foreach (PgFunction function in schema.Functions) { Console.WriteLine("Generating documentation for function \"{0}\".", function.Name); FunctionRunner.Run(function); } foreach (PgFunction function in schema.TriggerFunctions) { Console.WriteLine("Generating documentation for trigger function \"{0}\".", function.Name); FunctionRunner.Run(function); } foreach (PgMaterializedView materializedView in schema.MaterializedViews) { Console.WriteLine("Generating documentation for materialized view \"{0}\".", materializedView.Name); MaterializedViewRunner.Run(materializedView); } foreach (PgView view in schema.Views) { Console.WriteLine("Generating documentation for view \"{0}\".", view.Name); ViewRunner.Run(view); } foreach (PgType type in schema.Types) { Console.WriteLine("Generating documentation for type \"{0}\".", type.Name); TypeRunner.Run(type); } string targetPath = System.IO.Path.Combine(OutputPath, schemaName + ".html"); FileHelper.WriteFile(content, targetPath); }
public void FailureSecond() { IScanner scanner = Provider.Scanner; SequenceParser parser = new SequenceParser(First, Second2); ParserMatch m = parser.Parse(scanner); Assert.IsTrue(!m.Success); Assert.AreEqual(scanner.Offset, 0); }
public static void Main(string[] args) { SequenceParser.WarningMessage(); Console.WriteLine("Task 1 : Enter a sequence of positive integer digits (like: '1 2 3' or '1,2,3') \nto get sum and average"); List <int> list = SequenceParser.StringNumberSequenceToList(Console.ReadLine()); Console.WriteLine($"Sum: {list.Sum()}"); Console.WriteLine($"Average: {list.Average()}"); }
public void FailureFirst() { IScanner scanner = Provider.NewScanner; SequenceParser parser = new SequenceParser(Second, Second2); ParserMatch m = parser.Parse(scanner); Assert.IsFalse(m.Success); Assert.AreEqual(0, scanner.Offset); }
public void Constructor() { IScanner scanner = Provider.Scanner; Parser f = First; Parser s = Second; SequenceParser parser = new SequenceParser(f, s); Assert.AreEqual(parser.FirstParser, f); Assert.AreEqual(parser.SecondParser, s); }
public JsonGrammar() : base("json") { EnableMatchEvents = false; CaseSensitive = true; // terminals var jstring = new StringParser { AllowEscapeCharacters = true, Name = "string" }; var jnumber = new NumberParser { AllowExponent = true, AllowSign = true, AllowDecimal = true, Name = "number" }; var jboolean = new BooleanTerminal { Name = "bool", TrueValues = new[] { "true" }, FalseValues = new[] { "false" }, CaseSensitive = false }; var jname = new StringParser { AllowEscapeCharacters = true, Name = "name" }; var jnull = new LiteralTerminal { Value = "null", Name = "null", CaseSensitive = false }; var ws = new RepeatCharTerminal(char.IsWhiteSpace); var commaDelimiter = new RepeatCharTerminal(new RepeatCharItem(char.IsWhiteSpace), ',', new RepeatCharItem(char.IsWhiteSpace)); // nonterminals (things we're interested in getting back) var jobject = new SequenceParser { Name = "object" }; var jarray = new SequenceParser { Name = "array" }; var jprop = new SequenceParser { Name = "property" }; // rules AlternativeParser jvalue = jstring | jnumber | jobject | jarray | jboolean | jnull; jobject.Add("{", (-jprop).SeparatedBy(commaDelimiter), "}"); jprop.Add(jname, ":", jvalue); jarray.Add("[", (-jvalue).SeparatedBy(commaDelimiter), "]"); // separate sequence and repeating parsers by whitespace jvalue.SeparateChildrenBy(ws, false); // allow whitespace before and after the initial object or array Inner = ws & (jobject | jarray) & ws; }
public EbnfGrammar() : base("ebnf") { DefineCommonNonTerminals = true; GenerateSpecialSequences(); // terminals AlternativeParser terminal_string = ("'" & (+Terminals.AnyChar).Until("'").WithName("value") & "'") | ("\"" & (+Terminals.AnyChar).Until("\"").WithName("value") & "\"") | ("’" & (+Terminals.AnyChar).Until("’").WithName("value") & "’"); SequenceParser special_sequence = ("?" & (+Terminals.AnyChar).Until("?").WithName("name") & "?").WithName("special sequence"); SequenceParser meta_identifier_terminal = Terminals.Letter & -(Terminals.LetterOrDigit | '_'); var integer = new NumberParser(); Parser old = DefaultSeparator; DefaultSeparator = cws; // nonterminals var definition_list = new UnaryParser("definition list"); var single_definition = new UnaryParser("single definition"); var term = new UnaryParser("term"); var primary = new UnaryParser("primary"); var exception = new UnaryParser("exception"); var factor = new UnaryParser("factor"); var meta_identifier = new UnaryParser("meta identifier"); var syntax_rule = new UnaryParser("syntax rule"); var rule_equals = new UnaryParser("equals"); SequenceParser optional_sequence = ("[" & definition_list & "]").WithName("optional sequence"); SequenceParser repeated_sequence = ("{" & definition_list & "}").WithName("repeated sequence"); SequenceParser grouped_sequence = ("(" & definition_list & ")").WithName("grouped sequence"); // rules meta_identifier.Inner = (+meta_identifier_terminal).SeparatedBy(ws); primary.Inner = optional_sequence | repeated_sequence | special_sequence | grouped_sequence | meta_identifier | terminal_string.Named("terminal string") | null; factor.Inner = ~(integer.Named("integer") & "*") & primary; term.Inner = factor & ~("-" & exception); exception.Inner = term; single_definition.Inner = term & -("," & term); definition_list.Inner = single_definition & -("|" & single_definition); rule_equals.Inner = (Parser)"=" | ":="; syntax_rule.Inner = meta_identifier & rule_equals & definition_list & ";"; Inner = cws & +syntax_rule & cws; DefaultSeparator = old; AttachEvents(); }
public Sequence ParseSequence(String seqStr) { SequenceParserEnvironmentInterpreted parserEnv = new SequenceParserEnvironmentInterpreted(curActions); List <string> warnings = new List <string>(); Sequence seq = SequenceParser.ParseSequence(seqStr, parserEnv, warnings); foreach (string warning in warnings) { System.Console.Error.WriteLine(warning); } return(seq); }
public void Success() { IScanner scanner = Provider.Scanner; SequenceParser parser = new SequenceParser(First, Second); ParserMatch m = parser.Parse(scanner); Assert.IsTrue(m.Success); Assert.AreEqual(m.Offset, 0); Assert.AreEqual(scanner.Offset, m.Offset + m.Length); Assert.AreEqual(m.Value, First.MatchedString + Second.MatchedString); }
private SequenceParser EnsureCommandParses(string command) { var parser = new SequenceParser(); for (var i = 0; i < command.Length - 1; ++i) { Assert.AreEqual(ParserAppendResult.Pending, parser.Append(command[i])); } Assert.AreEqual(ParserAppendResult.Complete, parser.Append(command[command.Length - 1])); return(parser); }
public BnfGrammar(bool enhanced = true) : base("bnf") { if (enhanced) { foreach (PropertyInfo property in typeof(Terminals).GetProperties()) { if (typeof(Parser).IsAssignableFrom(property.PropertyType)) { var parser = property.GetValue(null, null) as Parser; baseLookup[property.Name] = parser.Named(property.Name); } } } SequenceParser lineEnd = sws & +(sws & Terminals.Eol); literal = ( (sq & (+!sq).Named("value").Optional() & sq) | (dq & (+!dq).Named("value").Optional() & dq) ).Named("parser"); RuleNameParser = "<" & Terminals.Set('>').Inverse().Repeat().Named("name") & ">"; RuleParser = new AlternativeParser(); // defined later TermParser = literal | (ruleName = RuleNameParser.Named("parser")); if (enhanced) { TermParser.Items.Add('(' & sws & RuleParser & sws & ')'); TermParser.Items.Add(repeatRule = ('{' & sws & RuleParser & sws & '}').Named("parser")); TermParser.Items.Add(optionalRule = ('[' & sws & RuleParser & sws & ']').Named("parser")); } list = (TermParser.Named("term") & -(~((+Terminals.SingleLineWhiteSpace).Named("ws")) & TermParser.Named("term"))).Named("parser"); listRepeat = (list.Named("list") & ws & '|' & sws & ~(RuleParser.Named("expression"))).Named("parser"); RuleParser.Items.Add(listRepeat); RuleParser.Items.Add(list); rule = (~lineEnd & sws & RuleNameParser.Named("ruleName") & ws & ruleSeparator & sws & RuleParser & lineEnd). Named("parser"); Expresssions = new AlternativeParser(); Expresssions.Items.Add(rule); Inner = ws & +Expresssions & ws; AttachEvents(); }
public static void Main(string[] args) { SequenceParser.WarningMessage(); Console.WriteLine("Task 9 : ENTER an integer to specify the starting point (example: 2)"); Console.WriteLine(".. Using the Queue<T> class write a program to print its first 50 members for given N. .."); int inputNumber = int.Parse(Console.ReadLine()); var queue = GeneratQueueeElements(inputNumber, 50); PrintQueueElemenets(queue); }
public void SequenceParser_ForArrayWithDuplicates_ShouldReturn3() { //Arrange int[] arr = new int[] { 100, 4, 200, 101, 3, 4, 102 }; SequenceParser seq = new SequenceParser(arr); int expected = 3; //{100,101,102} //Act int len = seq.GetLongestSequenceLength(); //Assert Assert.Equal(expected, len); }
public void SequenceParser_ForReverseArray_ShouldReturnArrayLength() { //Arrange int[] arr = new int[] { 100, 99, 98, 97, 96, 95, 94 }; SequenceParser seq = new SequenceParser(arr); int expected = 7; //{94,95,96,97,98,99,100} //Act int len = seq.GetLongestSequenceLength(); //Assert Assert.Equal(expected, len); }
public void SequenceParser_ForArray_ShouldReturn4() { //Arrange int[] arr = new int[] { 100, 4, 200, 1, 3, 2 }; SequenceParser seq = new SequenceParser(arr); int expected = 4; //{1,2,3,4} //Act int len = seq.GetLongestSequenceLength(); //Assert Assert.Equal(expected, len); }
public SequenceExpression ParseSequenceExpression(String seqExprStr) { Dictionary <String, String> predefinedVariables = new Dictionary <string, string>(); SequenceParserEnvironmentInterpreted parserEnv = new SequenceParserEnvironmentInterpreted(curActions); List <string> warnings = new List <string>(); SequenceExpression seqExpr = SequenceParser.ParseSequenceExpression(seqExprStr, predefinedVariables, parserEnv, warnings); foreach (string warning in warnings) { System.Console.Error.WriteLine(warning); } return(seqExpr); }
public static void Main(string[] args) { SequenceParser.WarningMessage(); Console.WriteLine("Task 6 : Enter sequence of Interegers (like: ' 4, 2, 2, 5, 2, 3, 2, 3, 1, 5, 2 ')"); Console.WriteLine("Program that removes from given sequence all numbers that occur odd number of times."); var digits = SequenceParser.StringNumberSequenceToList(Console.ReadLine()); digits = RemoveAllOddTimesOccuranceElementsWithFind(digits); digits.ForEach(x => Console.Write(x + " ")); Console.WriteLine(); }
public static void Main(string[] args) { SequenceParser.WarningMessage(); Console.WriteLine("Task 4 : Enter sequence of Interegers (like: '1 2 2 2 3' or '1, 2, 2, 2, 3')"); Console.WriteLine("To find the longest subsequence of equal digits (like: 2 2 2)"); var digits = SequenceParser.StringNumberSequenceToList(Console.ReadLine()); var result = MaximalSubsequenceOfEquals(digits); result.ForEach(x => Console.Write(x + " ")); Console.WriteLine(); }
public CBFFGrammar() : base("CBFF Definition") { EnableMatchEvents = false; CaseSensitive = true; // terminals var jstring = new StringParser { AllowEscapeCharacters = true, AllowDoubleQuote = false, AllowNonQuoted = true, Name = "string", QuoteCharacters = null }; var jnumber = new NumberParser { AllowExponent = true, AllowSign = true, AllowDecimal = true, Name = "number" }; var jboolean = new BooleanTerminal { Name = "bool", TrueValues = new string[] { "true" }, FalseValues = new string[] { "false" }, CaseSensitive = false }; var jname = new StringParser { AllowDoubleQuote = false, AllowEscapeCharacters = true, AllowNonQuoted = true, Name = "name", QuoteCharacters = null }; var jnull = new LiteralTerminal { Value = "null", Name = "null", CaseSensitive = false }; var ws = new RepeatCharTerminal(char.IsWhiteSpace); var commaDelimiter = new RepeatCharTerminal(new RepeatCharItem(char.IsWhiteSpace), ';', new RepeatCharItem(char.IsWhiteSpace)); // nonterminals (things we're interested in getting back) var jobject = new SequenceParser { Name = "object" }; var jarray = new SequenceParser { Name = "array" }; var jprop = new SequenceParser { Name = "property" }; // rules var jvalue = jstring | jnumber | jobject | jarray | jboolean | jnull; jobject.Add((+Terminals.LetterOrDigit).Named("NodeName") & ws & "{", ws & -((jprop & -Terminals.Set(';')) | jobject | jarray) & ws, "}"); jprop.Add(jname, ":", jvalue); jarray.Add((+Terminals.LetterOrDigit).Named("NodeName") & ws & "[", ws & -((jprop & -Terminals.Set(';')) | jobject | jarray) & ws, "]"); // separate sequence and repeating parsers by whitespace jvalue.SeparateChildrenBy(ws, false); // allow whitespace before and after the initial object or array this.Inner = ws & +(jobject | jarray) & ws; }
public static SequenceParser Then(this Parser parser, params Parser[] parsers) { var sequence = parser as SequenceParser; if (sequence == null || !sequence.Reusable) { sequence = new SequenceParser(parser) { Reusable = true } } ; sequence.Items.AddRange(parsers); return(sequence); }
public static void Main(string[] args) { SequenceParser.WarningMessage(); var qu = new Queue <int>(); for (int i = 0; i < 50; i++) { qu.Enqueue(i); } for (int i = 0; i < 50; i++) { Console.Write($" {qu.Dequeue()} "); } }
public static void Main(string[] args) { SequenceParser.WarningMessage(); Console.WriteLine("Task 3 : Enter sequence of Interegers (like: '1 -2 3' or '1,-2,3') to sort in increasing order"); var digits = SequenceParser.StringNumberSequenceToList(Console.ReadLine()); //// digits.Sort(); var instance = new SelectionSort(); instance.Sort(digits); Console.WriteLine("Ordered : "); digits.ForEach(x => Console.Write(x + " ")); Console.WriteLine("Done! "); }
private Parser SingleDefinition(Match match, bool isTerminal) { Match[] terms = match.Find("term").ToArray(); if (terms.Length == 1) { return(Term(terms[0], isTerminal)); } else { var sequence = new SequenceParser(terms.Select(r => Term(r, isTerminal))); if (!isTerminal) { sequence.Separator = separator; } return(sequence); } }
public static void Main(string[] args) { SequenceParser.WarningMessage(); Console.WriteLine("Task 10 : ENTER an integer to specify the START point (example: 5) \n and then ENTER ENDING POINT"); Console.WriteLine(" .. N2 = N+1 ; N3 = N+2; N4 = N*2 .. Write a program that finds the shortest sequence of operations \nfrom the list above that starts from N and finishes in M.. .."); Console.WriteLine("Enter N :"); var start = int.Parse(Console.ReadLine()); Console.WriteLine("Enter M : "); var end = int.Parse(Console.ReadLine()); var queue = GeneratQueueeElements(start, end); PrintQueueElemenets(queue); }