public PowerCalc()
{
InitializeComponent();
ParserFactory.InitializeFactoryFromResource("Power_Calc.Calculator.cgt");
m_parser = new MyParser(Output);
m_index = 2;
}
static void Main(string[] args)
{
string dashes = "---------------------------------------------";
// Console BS
Console.Clear();
Console.Title = $"Remix 0.1a";
Console.BackgroundColor = ConsoleColor.Blue;
Console.ForegroundColor = ConsoleColor.White;
Console.BufferHeight = Console.WindowHeight;
Console.WriteLine($"{dashes}\r\n Remix 0.1a [{DateTime.Now.ToShortDateString()} {DateTime.Now.ToLongTimeString()}]\r\n{dashes}\r\n");
// Parser Setup
string file = args.Length > 0 ? args[0] : "main.rmx";
if (File.Exists(file))
{
TextReader reader = File.OpenText("main.rmx");
MyParser parser = new MyParser();
parser.Setup();
parser.Parse(reader);
// Wait for user input to exit
Console.WriteLine($"\r\n{dashes}\r\n\r\nPress any key to close this window...");
Console.ReadKey();
}
else
{
Console.WriteLine("No input file found.");
Console.WriteLine($"\r\nPress any key to close this window...");
Console.ReadKey();
}
}
private void Button_Click(object sender, RoutedEventArgs e)
{
Circuit.Reset();
string expr = LogicalExpression.Text;
List <Token> tokens = new List <Token>();
StringReader reader = new StringReader(expr);
try
{
//Tokenize the expression
Token t = null;
do
{
t = new Token(reader);
tokens.Add(t);
} while (t.type != Token.TokenType.EXPR_END);
//Use a minimal version of the Shunting Yard algorithm to transform the token list to polish notation
List <Token> polishNotation = MyParser.TransformToPolishNotation(tokens);
var enumerator = polishNotation.GetEnumerator();
enumerator.MoveNext();
exp = MyParser.Make(ref enumerator);
exp.Paint(ct);
//LogicalExpression.Text = exp.GetStringExp();
var result = exp.Evaluate(ct);
Circuit.AddLamp();
Circuit.SwitchLamp(result);
}
catch (Exception ex)
{
MessageBox.Show($"Gabim ne shprehje: {ex.Message}");
}
}
public void ParseInfixExpression_ExpectGoodResults_GetCorrectPostfixNotationOut()
{
var expression1 = new List <string>();
var expected1 = new List <string>()
{
{ "5" }, { "3" }, { "2" }, { "/" }, { "+" }
};
expression1.Add("5");
expression1.Add("+");
expression1.Add("3");
expression1.Add("/");
expression1.Add("2");
var expression2 = new List <string>();
var expected2 = new List <string>()
{
{ "5" }, { "3" }, { "/" }, { "2" }, { "+" }
};
expression2.Add("5");
expression2.Add("/");
expression2.Add("3");
expression2.Add("+");
expression2.Add("2");
var myParser = new MyParser();
var result1 = new List <string>(myParser.Execute(expression1));
var result2 = new List <string>(myParser.Execute(expression2));
Assert.IsTrue(ShallowListEquality.Test(expected1, result1));
Assert.IsTrue(ShallowListEquality.Test(expected2, result2));
}
public static IText ParseText(string path)
{
IText parsedText = new MyParser().ParseText(new StreamReader(path));
//SerializeOjectModel(parsedText);
return(parsedText);
}
public void ProcessContextThrowsWhenConversionLogicThrows()
{
var converterMock = new Mock <IValueConverter <string> >();
converterMock.Setup(m => m.Convert(It.IsAny <string>())).Throws <Exception>();
var parser = new MyParser(null, ParserType.Command, converterMock.Object, null, _mockMapper.Object);
Should.Throw <ConversionException>(() => parser.ProcessContext(null, null));
}
/// <summary>
/// Liefert die Commits mit dem dazugehörigen Developer
/// </summary>
public static Commit[] ReadFromCsv()
{
string filePath = MyFile.GetFullNameInApplicationTree(Filename);
List <Commit> commits = new List <Commit>();
Dictionary <string, Developer> developers = new Dictionary <string, Developer>();
if (File.Exists(filePath) == false)
{
throw new Exception("File does not exist");
}
string[] lines = File.ReadAllLines(filePath, Encoding.UTF8);
HeaderDto headerDto = null;
FooterDto footerDto = null;
foreach (string line in lines)
{
string[] data = line.Split(',');
headerDto = MyParser.TryParseCommitHeader(line);
if (headerDto != null)
{
Developer developer;
if (developers.TryGetValue(headerDto.DeveloperName, out developer) == false)
{
developer = new Developer
{
Name = headerDto.DeveloperName
};
developers[headerDto.DeveloperName] = developer;
}
commits.Add(new Commit
{
HashCode = headerDto.HashCode,
Developer = developer,
Date = headerDto.CommitDate,
Message = headerDto.Message,
FilesChanges = 0,
Insertions = 0,
Deletions = 0
});
}
footerDto = MyParser.TryParseCommitFooter(line);
if (footerDto != null && commits.Count > 0)
{
Commit lastCommit = commits.Last();
lastCommit.FilesChanges = footerDto.FilesChanges;
lastCommit.Insertions = footerDto.Insertions;
lastCommit.Deletions = footerDto.Deletions;
}
}
return(commits.ToArray());
}
public void MultiValuedReturnsMapperValue()
{
_mockMapper.SetupGet(m => m.MultiValued).Returns(true);
var parser = new MyParser(null, ParserType.PositionArgument,
_mockConverter.Object,
null,
_mockMapper.Object);
parser.MultiValued.ShouldBeTrue();
}
public void ProcessContextThrowsWhenValidationThrows()
{
var validatorMock = new Mock <IValidator <string> >();
validatorMock.Setup(m => m.Validate(It.IsAny <string>())).Throws <Exception>();
var parser = new MyParser(null, ParserType.Command, _mockConverter.Object,
validatorMock.Object,
_mockMapper.Object);
Should.Throw <ConfigurationException>(() => parser.ProcessContext(null, null));
}
public void AcceptArgumentValueInvokesValidator()
{
_mockValidator.Setup(m => m.Validate("test")).Returns(true).Verifiable();
var parser = new MyParser(null, ParserType.Command, ConverterFactory.CreateOrThrow <string>(),
_mockValidator.Object, _mockMapper.Object);
parser.ProcessContext(new object(), new ParseContext(Enumerable.Empty <string>()));
_mockValidator.Verify(m => m.Validate("test"), Times.Once);
}
public void AcceptArgumentValueInvokesConverter()
{
_mockConverter.Setup(m => m.Convert("test")).Verifiable();
var parser = new MyParser(null, ParserType.Command, _mockConverter.Object,
null, _mockMapper.Object);
parser.ProcessContext(new object(), new ParseContext(Enumerable.Empty <string>()));
_mockConverter.Verify(m => m.Convert("test"), Times.Once());
}
public void AcceptArgumentValueInvokesMapper()
{
var options = new object();
var parser = new MyParser(null, ParserType.Command, ConverterFactory.CreateOrThrow <string>(),
null,
_mockMapper.Object);
_mockMapper.Setup(m => m.MapValue(options, "test")).Verifiable();
parser.ProcessContext(options, new ParseContext(Enumerable.Empty <string>()));
_mockMapper.Verify(m => m.MapValue(options, "test"), Times.Once);
}
public static void Main()
{
MyParser.ParseObj(new
{
Str = "abc"
, Num = 543
, Arr = new[] { 1, 2, 3 }
, Chars = new char[] { 'x', 'y', 'z' }
, SomeList = new List <string>()
{
"a", "b", "c"
}
});
}
private void button1_Click(object sender, EventArgs e)
{
richTextBox2.Clear();
pars = new MyParser(Application.StartupPath + "\\prolog.cgt");
pars.Parse(richTextBox1.Text);
if (pars.message == "")
{
richTextBox2.Text = "correct";
}
else
{
richTextBox2.Text = pars.message;
}
}
public void FindEqualShapes_PositiveTestResult(params Polygon[] shapes)
{
Assert.AreNotEqual(null, _reader.ReadingCSVDataFromTextFile(_figuresFilePath));
List <Polygon> shapesFromFile = MyParser.ParseCSVDataFromFile(_reader.ReadingCSVDataFromTextFile(_figuresFilePath));
Assert.AreNotEqual(null, shapesFromFile);
List <Polygon> eqaulShapes = (from Polygon shape in shapes
where shapesFromFile.Any(s => s.Equals(shape))
select shapesFromFile.FirstOrDefault(s => s.Equals(shape))).ToList();
Assert.IsTrue(eqaulShapes.Count != 0);
}
static void Main(string[] args)
{
//make true for skip Task_2_Exception_1
bool closeProgram = true;
Console.WriteLine("Number of lines: ");
while (!closeProgram)
{
if (int.TryParse(Console.ReadLine(), out int numberOfLines))
{
List <string> lines = new List <string>();
for (int i = 0; i < numberOfLines; i++)
{
Console.WriteLine($"Enter line number {i + 1}: ");
lines.Add(Console.ReadLine());
}
Console.WriteLine("__________________________________________________________\n\n");
for (int i = 0; i < numberOfLines; i++)
{
string lineWithoutSpaces = lines.ElementAt(i).Replace(" ", "");
if (lineWithoutSpaces.Length > 0)
{
char firstLetter = lineWithoutSpaces[0];
Console.WriteLine($"First letter of line {i + 1}: {firstLetter}");
}
else
{
Console.WriteLine($"Line {i + 1} is empty! :c");
}
}
closeProgram = true;
}
else
{
Console.WriteLine("It's not a number! Please, try again: ");
}
}
// remove comment for Testing Task_2_Exception_2 library
MyParser.StringToInt(" ", out int targetNumber);
}
/// <summary>
/// Compila um código qualquer em um objeto final com base na gramática
/// </summary>
/// <param name="code">Código de entrada</param>
/// <returns>Objeto compilado</returns>
public T Compile(string code)
{
var scanner = new MyScanner(_grammar);
var parser = new MyParser(_grammar);
var input = new CodeStringStream(code);
// Executa a análise léxica
var tokens = scanner.Run(input);
// Executa a análise sintática
var syntaxTree = parser.Run(tokens);
// Emite (compila) o objeto compilado final
var output = _emitter(syntaxTree);
return(output);
}
//4. В некотором предложении текста слова заданной длины заменить указанной подстрокой, длина которой может не совпадать с длиной слова.
public static ISentence ReplaceWordBySubstring(ISentence sentence, int length, string newSubstring)
{
length = ValidateLength(length);
newSubstring = ValidateString(newSubstring);
IList <ISentenceItem> substring = new MyParser().ParseSentence(newSubstring);
ISentence changedSentence = sentence;
for (int i = 0; i < sentence.Items.Count; i++)
{
if (changedSentence.Items[i] is Word && changedSentence.Items[i].Length == length)
{
changedSentence.ReplaceWord(changedSentence.Items[i] as Word, substring);
}
}
return(changedSentence);
}
public static void parse(TextReader inputSource,
XmlObjectResultsHandler handler,
bool validate)
{
XmlReaderSettings mySettings =
new XmlReaderSettings();
if (validate)
{
mySettings.ValidationType = ValidationType.DTD;
}
mySettings.ProhibitDtd = false;
mySettings.XmlResolver = new MyEntityResolver(validate);
XmlReader reader = XmlReader.Create(inputSource, mySettings);
MyParser parser = new MyParser(handler);
parser.Parse(reader);
}
private void Compilar_Click(object sender, EventArgs e)
{
MyParser parser = new MyParser(pathArchivo + "\\DecafGP.cgt");
TreeNode tree = parser.Parse(TextArea.Text);
treeView1.Nodes.Clear();
if (tree != null)
{
treeView1.Nodes.Add(tree);
//statusLabel.Text = @"Success";
}
else
{
//statusLabel.Text = parser.ErrorMessage;
}
}
public void ParseInfixExpression_AppropriateResultsWithParenthesis()
{
var expression3 = new List <string>();
var expected3 = new List <string>()
{
{ "1" }, { "2" }, { "3" }, { "*" }, { "+" }
};
expression3.Add("1");
expression3.Add("+");
expression3.Add("(");
expression3.Add("2");
expression3.Add("*");
expression3.Add("3");
expression3.Add(")");
var expression4 = new List <string>();
var expected4 = new List <string>()
{
{ "1" }, { "2" }, { "+" }, { "3" }, { "*" }
};
expression4.Add("(");
expression4.Add("1");
expression4.Add("+");
expression4.Add("2");
expression4.Add(")");
expression4.Add("*");
expression4.Add("3");
var myParser = new MyParser();
var result3 = new List <string>(myParser.Execute(expression3));
var result4 = new List <string>(myParser.Execute(expression4));
Assert.IsTrue(ShallowListEquality.Test(expected3, result3));
Assert.IsTrue(ShallowListEquality.Test(expected4, result4));
}
static void Main(string[] args)
{
Console.WriteLine(GetDirectory());
Console.ReadKey();
Stack s = new Stack();
MyParser parser = new MyParser(s);
ParserFactory.InitializeFactoryFromFile(Path.Combine(GetDirectory(), "cgt.cgt"));
parser.Parse(File.ReadAllText(Path.Combine(GetDirectory(), "simpletest.txt")));
if (parser.SyntaxTree != null)
{
//if (parser.SyntaxTree.LeftmostChild != null)
//{
// Console.WriteLine(parser.SyntaxTree.LeftmostChild.GetType());
//}
//if (parser.SyntaxTree.Parent != null)
//{
// Console.WriteLine(parser.SyntaxTree.Parent.GetType());
//}
//if (parser.SyntaxTree.LeftmostSibling != null)
//{
// Console.WriteLine(parser.SyntaxTree.LeftmostSibling.GetType());
//}
//if (parser.SyntaxTree.RightSibling != null)
//{
// Console.WriteLine(parser.SyntaxTree.RightSibling.GetType());
//}
PrintAST(parser.SyntaxTree);
}
else
{
Console.WriteLine("syntax tree is null");
}
WriteNodesToConsole(parser.Stack.GetNodes);
Console.ReadKey();
}
private static void TagFormat()
{
string res = "";
MyParser parser = new MyParser(res);
RtfReader reader = new RtfReader(parser);
reader.LoadRtfFile("..\\..\\testdocs\\test-doc2.rtf");
Console.WriteLine("Processing...");
reader.Parse();
StreamWriter sw = new StreamWriter("..\\..\\testdocs\\taggedfile.txt");
sw.Write(parser.doc);
sw.Flush();
sw.Close();
Console.WriteLine("File 'taggedfile.txt' created.");
Console.WriteLine("");
}
public void CreateSyntaxTree()
{
string expr = @"(A&B)";
List <Token> tokens = new List <Token>();
StringReader reader = new StringReader(expr);
//Tokenize the expression
Token t = null;
do
{
t = new Token(reader);
tokens.Add(t);
} while (t.type != Token.TokenType.EXPR_END);
//Use a minimal version of the Shunting Yard algorithm to transform the token list to polish notation
List <Token> polishNotation = MyParser.TransformToPolishNotation(tokens);
var enumerator = polishNotation.GetEnumerator();
enumerator.MoveNext();
BooleanExp root = MyParser.Make(ref enumerator);
var str = root.GetStringExp();
}
static int Main(string[] args)
{
MyParser myParser;
string grammarTable = "GramaticaFinal.cgt";
string testFile, programText;
if (args.Length == 0)
{
System.Console.WriteLine("Cantidad de argumentos incorrecta.");
System.Console.WriteLine("Uso: SuficienciaLYC.exe codigo.txt");
return(1);
}
myParser = new MyParser(grammarTable);
testFile = args[0];
programText = System.IO.File.ReadAllText(testFile);
myParser.Parse(programText);
return(0);
}
/// <summary>
/// Read a CSV file and use delegate method to parse the lines
/// </summary>
/// <example>
/// public static object CsvDoubleParser(string[] splittedLine)
/// {
/// // only store the second element (the first is a counter)
/// return double.Parse(splittedLine[1]);
/// }
/// var objects = IOUtils.ReadCSV("input.csv", false, CsvDoubleParser);
/// var doubles = objects.Cast<double>().ToArray();
/// </example>
/// <param name="filePath">file path</param>
/// <param name="hasHeader">whether we should skip the first header row</param>
/// <param name="parser">a parser delegate method</param>
/// <returns>a list of objects that can be casted to whatever</returns>
public static List <object> ReadCSV(string filePath, bool hasHeader, MyParser parser)
{
int lineCounter = 0;
var list = new List <object>();
// read in the dictionary file in the ord10k.csv format
foreach (var line in File.ReadLines(filePath, _isoLatin1Encoding))
{
lineCounter++;
// skip header
if (hasHeader && lineCounter == 1)
{
continue;
}
// ignore blank lines
if (string.IsNullOrEmpty(line))
{
continue;
}
// parse
var elements = line.Split(new String[] {
columnSeparator
}, StringSplitOptions.RemoveEmptyEntries);
list.Add(parser(elements));
//word.Place = int.Parse(elements[0]);
//word.Frequency = int.Parse(elements[1]);
//word.Word = elements[4];
}
return(list);
}
public void Post(JObject data)
{
database.updVacansy(data.GetValue("name").ToString(), MyParser.ParseVacansy(data));
}
private static void TagFormat()
{
string res = "";
MyParser parser = new MyParser(res);
RtfReader reader = new RtfReader(parser);
reader.LoadRtfFile("..\\..\\testdocs\\test-doc2.rtf");
Console.WriteLine("Processing...");
reader.Parse();
StreamWriter sw = new StreamWriter("..\\..\\testdocs\\taggedfile.txt");
sw.Write(parser.doc);
sw.Flush();
sw.Close();
Console.WriteLine("File 'taggedfile.txt' created.");
Console.WriteLine("");
}
public Form1()
{
parser = new MyParser(Application.StartupPath + "\\Calculadora.cgt");
InitializeComponent();
}
public override int readValue(MyParser myParser)
{
return(myParser.readInt());
}
public abstract T readValue(MyParser myParser);
public static void parse(TextReader inputSource,
XmlObjectResultsHandler handler,
bool validate)
{
XmlReaderSettings mySettings =
new XmlReaderSettings();
if (validate)
{
mySettings.ValidationType = ValidationType.DTD;
}
mySettings.DtdProcessing = DtdProcessing.Parse;
//mySettings.ProhibitDtd = false;
mySettings.XmlResolver = new MyEntityResolver(validate);
XmlReader reader = XmlReader.Create(inputSource, mySettings);
MyParser parser = new MyParser(handler);
parser.Parse(reader);
}
