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