public void TestForLoop()
{
var test = @"
for(int i = 0;i < 10; i = i + 1){
i = 15;
print i;
}";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void TestSimpleAst()
{
var test = @"x = 1;";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
var expr = (ast.ScopedStatements[0] as Expr);
Assert.IsTrue(expr.Left.Token.TokenType == TokenType.Word);
Assert.IsTrue(expr.Right.Token.TokenType == TokenType.Int);
Assert.IsTrue(ast.Token.TokenType == TokenType.ScopeStart);
}
public void RunPrecedenceTests_WithBraces(string input, int expectedOutput)
{
var tokens = LanguageParser.Parse(input);
var result = new InterpreterWithPrecedence(tokens)
.Run();
Assert.Equal(expectedOutput, result);
var pieces = input.Split(Environment.NewLine + Environment.NewLine);
var record = RulesParser.ParseRules(pieces[0]);
var count = record.CountValidMessages("0", pieces[1].Split(Environment.NewLine));
Assert.Equal(279, count);
}
private ICustomFormatSpecification InitializeSpecification(Match match)
{
var type = match.Groups["type"].Value.ToLower();
var value = match.Groups["value"].Value.ToLower();
var isRegex = match.Groups["m_r"].Success;
switch (type)
{
case "r":
return(new ResolutionSpecification {
Value = (int)ParseResolution(value)
});
case "s":
return(new SourceSpecification {
Value = (int)ParseSource(value)
});
case "m":
return(new QualityModifierSpecification {
Value = (int)ParseModifier(value)
});
case "e":
return(new EditionSpecification {
Value = ParseString(value, isRegex)
});
case "l":
return(new LanguageSpecification {
Value = (int)LanguageParser.ParseLanguages(value).First()
});
case "i":
return(new IndexerFlagSpecification {
Value = (int)ParseIndexerFlag(value)
});
case "g":
var minMax = ParseSize(value);
return(new SizeSpecification {
Min = minMax.Item1, Max = minMax.Item2
});
case "c":
default:
return(new ReleaseTitleSpecification {
Value = ParseString(value, isRegex)
});
}
}
public void FunctionTest()
{
var test = @"void foo(int x, int y){
int x = 1;
var z = fun() -> {
zinger = ""your mom!"";
someThing(a + b) + 25 - (""test"" + 5);
};
}
z = 3;
int testFunction(){
var p = 23;
if(foo){
var x = 1;
}
else if(faa){
var y = 2;
var z = 3;
}
else{
while(1 + 1){
var x = fun () ->{
test = 0;
};
}
if(foo){
var x = 1;
}
else if(faa){
var y = 2;
var z = 3;
}
else{
for(int i = 0; i < 10; i = i + 1){
var x = z;
}
}
}
}";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
Assert.IsTrue(ast.ScopedStatements.Count == 3);
Assert.IsTrue(ast.ScopedStatements[0] is MethodDeclr);
Assert.IsTrue(ast.ScopedStatements[1] is Expr);
Assert.IsTrue(ast.ScopedStatements[2] is MethodDeclr);
}
public void Puzzle1()
{
var results = new List <long>();
var input = new FileReader()
.GetResource("AdventOfCode2020.Tests.Day18.PuzzleInput.txt");
foreach (var line in input.Split(Environment.NewLine))
{
var tokens = LanguageParser.Parse(line);
results.Add(new Interpreter(tokens).Run());
}
Assert.Equal(2743012121210, results.Sum());
}
public override ExtraFile Import(Series series, EpisodeFile episodeFile, string path, string extension, bool readOnly)
{
if (SubtitleFileExtensions.Extensions.Contains(Path.GetExtension(path)))
{
var subtitleFile = ImportFile(series, episodeFile, path, extension, readOnly);
subtitleFile.Language = LanguageParser.ParseSubtitleLanguage(path);
_subtitleFileService.Upsert(subtitleFile);
return(subtitleFile);
}
return(null);
}
public void TestInvalidAssignment2()
{
var test = @"
int x = func();
string func(){
return ""test"";
}
";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void TestBools()
{
var test = @"
var x = true & false || true;
while(x){
print x;
x = 1 > 2;
}
print x;";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void TestWhileLoop()
{
var test = @"
int x = 5;
while(x > 0){
print x;
x = x - 1;
}
print ""done!"";";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void TestInvalidReturnTypes()
{
var test = @"
int foo(string t){
var x = ""test"";
return x + t;
}
print foo(""pong"");";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void AstWithExpression()
{
var test = @"x = 1 + 2;";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
var expr = (ast.ScopedStatements[0] as Expr);
Assert.IsTrue(expr.Left.Token.TokenType == TokenType.Word);
Assert.IsTrue((expr.Right as Expr).Left.Token.TokenValue == "1");
Assert.IsTrue((expr.Right as Expr).Right.Token.TokenValue == "2");
Assert.IsTrue((expr.Right as Expr).Token.TokenValue == "+");
Assert.IsTrue((expr.Right as Expr).Token.TokenType == TokenType.Plus);
}
public void should_parse_language(string postTitle, params Language[] languages)
{
var movieInfo = Parser.Parser.ParseMovieTitle(postTitle, true);
var languageTitle = postTitle;
if (movieInfo != null)
{
languageTitle = movieInfo.SimpleReleaseTitle;
}
var result = LanguageParser.ParseLanguages(languageTitle);
result = LanguageParser.EnhanceLanguages(languageTitle, result);
result.Should().BeEquivalentTo(languages);
}
public void TestExpressionInterpreter()
{
var test = @"
int x = 100 + 1;
void foo(){
print (1 + 1);
}
print (x + 2 + (3 + 4));
foo();
foo();";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse();
new InterpretorVisitor().Start(ast);
}
public void TestForwardReferences3()
{
var test = @"
print item;
string item = func(""test"");
var func(string printer){
return ""yes"";
}
";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void TestFunctionInvalidTypeParamters()
{
var test = @"
var func(string printer, int x){
print printer;
print x;
}
func(""asdf"", ""asdf"");
";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public override ExtraFile Import(Movie movie, MovieFile movieFile, string path, string extension, bool readOnly)
{
if (SubtitleFileExtensions.Extensions.Contains(Path.GetExtension(path)))
{
var language = LanguageParser.ParseSubtitleLanguage(path);
var suffix = GetSuffix(language, 1, false);
var subtitleFile = ImportFile(movie, movieFile, path, readOnly, extension, suffix);
subtitleFile.Language = language;
_subtitleFileService.Upsert(subtitleFile);
return(subtitleFile);
}
return(null);
}
public void CreateDictionaryFromString_ExpectedBehavior(string input, string queriesToCheck)
{
Dictionary <string, int> dictionary = LanguageParser.CreateDictionaryFromString(input);
string[] split = queriesToCheck.Split(',');
foreach (string entry in split)
{
string[] entrySplit = entry.Split(':');
if (entrySplit.Length == 1)
{
return;
}
int indentation = int.Parse(entrySplit[1]);
Assert.AreEqual(dictionary[entrySplit[0]], indentation);
}
}
ProgramNode ParseModule(ModulePath?path, SourceText source, SyntaxContext context)
{
var msg = path != null ? $" with path '{path}'" : string.Empty;
if (!_loading.Add(source.FullPath))
{
throw new ModuleLoadException($"Module{msg} could not be loaded due to circular 'use' declarations.");
}
try
{
if (context.Parses.ContainsKey(source.FullPath))
{
throw new ModuleLoadException($"Module{msg} was already loaded previously.");
}
var lex = LanguageLexer.Lex(source);
var parse = LanguageParser.Parse(lex, SyntaxMode.Normal);
context.AddParse(source.FullPath, parse);
foreach (var diag in lex.Diagnostics)
{
context.AddDiagnostic(diag);
}
foreach (var diag in parse.Diagnostics)
{
context.AddDiagnostic(diag);
}
var analysis = LanguageAnalyzer.Analyze(parse, this, context);
foreach (var diag in analysis.Diagnostics)
{
context.AddDiagnostic(diag);
}
return(analysis.IsSuccess ? (ProgramNode)parse.Tree : throw new ModuleLoadException(
$"Module{msg} failed to load due to syntax and/or semantic errors."));
}
finally
{
_ = _loading.Remove(source.FullPath);
}
}
public static LeeSyntaxTree ParseText(SourceText text, ParseOptions options, string path = "")
{
if (text == null)
{
throw new ArgumentNullException(nameof(text));
}
using (var lexer = new Lexer(text, options))
{
using (var parser = new LanguageParser(lexer))
{
var compilationUnit = (CompilationUnitSyntax)parser.ParseCompilationUnit();
var tree = new ParsedSyntaxTree(text, path, options, compilationUnit, parser.Directives);
return(tree);
}
}
}
public void AstWithExpression2()
{
var test = @"int z = 1;
{
int y = 5 + 4;
}
x = 1 + 2 ^ (5-7);";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
Assert.IsTrue(ast.ScopedStatements.Count == 3);
Assert.IsTrue(ast.ScopedStatements[0] is VarDeclrAst);
Assert.IsTrue(ast.ScopedStatements[1].Token.TokenType == TokenType.ScopeStart);
Assert.IsTrue(ast.ScopedStatements[2] is Expr);
Console.WriteLine(ast);
}
public void TestArgumentInferWithLambdasAsMethodPassing()
{
var test = @"
var func(method printer, method printer2){
print printer();
printer2();
}
var x = fun() -> { print 'test'; return 1; };
func(x,x);
";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void Emit(CompilationContext context)
{
var grammar = System.Reflection.Assembly.GetExecutingAssembly().GetTypes()
.Where(c => c.Namespace == "CmC.Compiler.Syntax.Assembly" || c.Namespace == "CmC.Compiler.Syntax.Common")
.Where(c => typeof(ILanguageToken).IsAssignableFrom(c))
.Select(t => (ILanguageToken)Activator.CreateInstance(t, null)).ToList();
var generator = new ParserGenerator(grammar);
LanguageParser parser = generator.GetParser();
var tokens = parser.Parse(AssemblySource, "ASM_INSTRUCTION");
foreach (var token in tokens)
{
((ICodeEmitter)token).Emit(context);
}
}
static void Main(string[] args)
{
var files = new List <string> (args).Where(File.Exists);
var str = files.Select(File.ReadAllText)
.Aggregate(string.Empty, (acc, item) => acc + Environment.NewLine + item);
if (String.IsNullOrWhiteSpace(str))
{
Console.WriteLine("No available files for compilation");
return;
}
var ast = new LanguageParser(new Lexer(str)).Parse();
new InterpretorVisitor().Start(ast);
}
public override ExtraFile Import(Series series, EpisodeFile episodeFile, string path, string extension, bool readOnly)
{
if (SubtitleFileExtensions.Extensions.Contains(Path.GetExtension(path)))
{
var language = LanguageParser.ParseSubtitleLanguage(path);
var suffix = GetSuffix(language, 1, false);
var subtitleFile = ImportFile(series, episodeFile, path, readOnly, extension, suffix);
subtitleFile.Language = language;
_mediaFileAttributeService.SetFilePermissions(path);
_subtitleFileService.Upsert(subtitleFile);
return(subtitleFile);
}
return(null);
}
public void ForLoopTest()
{
var test = @"for(int i = 0; i < 10; i = i + 1){
var x = z;
}
";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse();
var topScope = (ast as ScopeDeclr).ScopedStatements[0];
var forLoop = topScope as ForLoop;
Assert.IsTrue(forLoop != null);
Assert.IsTrue(forLoop.Setup is VarDeclrAst);
Assert.IsTrue(forLoop.Predicate.Token.TokenType == TokenType.LessThan);
Assert.IsTrue(forLoop.Body.ScopedStatements.Count == 1);
}
private static void ProcessSourceText(string text, CompilationContext context)
{
var grammar = Assembly.GetExecutingAssembly().GetTypes()
.Where(c => c.Namespace == "CmC.Compiler.Syntax" || c.Namespace == "CmC.Compiler.Syntax.Common")
.Where(c => typeof(ILanguageToken).IsAssignableFrom(c))
.Select(t => (ILanguageToken)Activator.CreateInstance(t, null));
var generator = new ParserGenerator(grammar.ToList());
LanguageParser parser = generator.GetParser();
var tokens = parser.Parse(text);
foreach (var token in tokens)
{
((ICodeEmitter)token).Emit(context);
}
}
public void TestScope()
{
var test = @"
void foo(int p){
p = 1;
}
int z = 5;
while(z > 0){
z = z + 1;
foo();
}
";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse();
var visitor = new ScopeBuilderVisitor();
visitor.Start(ast);
}
public void TestFunctionInternalsBeingForwardReferences()
{
var test = @"
var func(string printer){
return foo(printer);
}
var foo(string printer){
return printer + ""foo"";
}
print func(""zing"");
";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void TestExpressionInterpreterFunctionArguments()
{
var test = @"
void foo(int x){
if(x > 2){
print ((x + 1) + 2);
}
else{
print (x);
}
}
foo(1);
foo(100);";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse();
new InterpretorVisitor().Start(ast);
}
