/// <summary>
/// Parser to turn lg content into an <see cref="LGFile"/>.
/// </summary>
/// <param name="content">Text content contains lg templates.</param>
/// <param name="id">id is the content identifier. If importResolver is null, id must be a full path string. </param>
/// <param name="importResolver">resolver to resolve LG import id to template text.</param>
/// <returns>new <see cref="LGFile"/> entity.</returns>
public static LGFile ParseText(string content, string id = "", ImportResolverDelegate importResolver = null)
{
importResolver = importResolver ?? DefaultFileResolver;
var lgFile = new LGFile(content: content, id: id, importResolver: importResolver);
var diagnostics = new List <Diagnostic>();
try
{
var(templates, imports, invalidTemplateErrors) = AntlrParse(content, id);
lgFile.Templates = templates;
lgFile.Imports = imports;
diagnostics.AddRange(invalidTemplateErrors);
lgFile.References = GetReferences(lgFile, importResolver);
var semanticErrors = new StaticChecker(lgFile).Check();
diagnostics.AddRange(semanticErrors);
}
catch (LGException ex)
{
diagnostics.AddRange(ex.Diagnostics);
}
catch (Exception err)
{
diagnostics.Add(BuildDiagnostic(err.Message, source: id));
}
lgFile.Diagnostics = diagnostics;
return(lgFile);
}
public void WariningTest(string input)
{
var engine = new TemplateEngine().AddFile(GetExampleFilePath(input));
var report = new StaticChecker().CheckTemplates(engine.Templates);
TestContext.WriteLine(string.Join("\n", report));
}
public void AddNumberAndString()
{
var binAst = BinExpr(Num(1), Str("3"), "/");
var staticChecker = new StaticChecker(new PrinterErrorListener());
Assert.IsFalse(binAst.Accept(staticChecker));
}
public void AddTwoNumbers()
{
var binAst = BinExpr(Num(1), Num(3), "+");
var staticChecker = new StaticChecker(new PrinterErrorListener());
Assert.IsTrue(binAst.Accept(staticChecker));
}
public void SubtractNumberAndStringFails()
{
var binAst = BinExpr(Num(1), Str("3"), "-");
var errorCollector = new PrinterErrorListener();
var staticChecker = new StaticChecker(errorCollector);
Assert.IsFalse(binAst.Accept(staticChecker) && (errorCollector.Count != 0));
}
public void SimpleIf()
{
var ast = If(BinExpr(Num(1), Num(1), ">"), Num(2), Num(3));
var errorListener = new PrinterErrorListener();
StaticChecker staticChecker = new StaticChecker(errorListener);
Assert.IsTrue(ast.Accept(staticChecker) && errorListener.Count == 0);
}
public void Variables1()
{
var let = Let(
Decls(
VarDecl("x", Num(1))
),
Seq(Var("x")));
var errors = new PrinterErrorListener();
var staticChecker = new StaticChecker(errors, InitialScope());
Assert.IsTrue(let.Accept(staticChecker) && errors.Count == 0);
}
public void EmptyLet()
{
var let = Let(
Decls(
),
Seq());
var errors = new PrinterErrorListener();
var staticChecker = new StaticChecker(errors, InitialScope());
Assert.IsTrue(let.Accept(staticChecker));
Assert.IsTrue(errors.Count == 0);
}
public void BasicArrayInstantiationFail()
{
var arrayInstDecl = VarDecl("a", ArrayInst("intArray", Num(1), Num(5)));
var let = Let(
Decls(arrayInstDecl),
Seq()
);
var errorCollector = new PrinterErrorListener();
var staticChecker = new StaticChecker(errorCollector, InitialScope());
Assert.IsFalse(let.Accept(staticChecker));
Assert.IsFalse(errorCollector.Count == 0);
}
public void BasicArrayDeclarationFails()
{
var arrayDecl = ArrayDecl("intArray", "unknowntype");
var let = Let(
Decls(arrayDecl),
Seq()
);
var errorCollector = new PrinterErrorListener();
var staticChecker = new StaticChecker(errorCollector, InitialScope());
Assert.IsFalse(let.Accept(staticChecker));
Assert.IsFalse(errorCollector.Count == 0);
}
public void BasicArrayAccess()
{
var arrayDecl = ArrayDecl("intArray", "int");
var arrayInstDecl = VarDecl("a", ArrayInst("intArray", Num(1), Num(5)));
var let = Let(
Decls(arrayDecl, arrayInstDecl),
Seq(ArrayAccess(Var("a"), Num(0)))
);
var errorCollector = new PrinterErrorListener();
var staticChecker = new StaticChecker(errorCollector, InitialScope());
Assert.IsTrue(let.Accept(staticChecker));
Assert.IsTrue(errorCollector.Count == 0);
Assert.IsTrue(let.ReturnType == TigerType.GetType <IntType>());
}
/// <summary>
/// Parser to turn lg content into a <see cref="Templates"/>.
/// </summary>
/// <param name="content">Text content contains lg templates.</param>
/// <param name="id">id is the identifier of content. If importResolver is null, id must be a full path string. </param>
/// <param name="importResolver">resolver to resolve LG import id to template text.</param>
/// <param name="expressionParser">expressionEngine parser engine for parsing expressions.</param>
/// <param name="cachedTemplates">give the file path and templates to avoid parsing and to improve performance.</param>
/// <returns>new <see cref="Templates"/> entity.</returns>
private static Templates InnerParseText(
string content,
string id = "",
ImportResolverDelegate importResolver = null,
ExpressionParser expressionParser = null,
Dictionary <string, Templates> cachedTemplates = null)
{
cachedTemplates = cachedTemplates ?? new Dictionary <string, Templates>();
if (cachedTemplates.ContainsKey(id))
{
return(cachedTemplates[id]);
}
importResolver = importResolver ?? DefaultFileResolver;
var lg = new Templates(content: content, id: id, importResolver: importResolver, expressionParser: expressionParser);
var diagnostics = new List <Diagnostic>();
try
{
var(templates, imports, invalidTemplateErrors, options) = AntlrParse(content, id);
lg.AddRange(templates);
lg.Imports = imports;
lg.Options = options;
diagnostics.AddRange(invalidTemplateErrors);
lg.References = GetReferences(lg, cachedTemplates);
var semanticErrors = new StaticChecker(lg).Check();
diagnostics.AddRange(semanticErrors);
}
catch (TemplateException ex)
{
diagnostics.AddRange(ex.Diagnostics);
}
catch (Exception err)
{
diagnostics.Add(BuildDiagnostic(err.Message, source: id));
}
lg.Diagnostics = diagnostics;
return(lg);
}
/// <summary>
/// Parser to turn lg content into a <see cref="Templates"/> based on the original LGFile.
/// </summary>
/// <param name="content">Text content contains lg templates.</param>
/// <param name="lg">original LGFile.</param>
/// <returns>new <see cref="Templates"/> entity.</returns>
public static Templates ParseTextWithRef(string content, Templates lg)
{
if (lg == null)
{
throw new ArgumentNullException(nameof(lg));
}
var id = "inline content";
var newLG = new Templates(content: content, id: id, importResolver: lg.ImportResolver, options: lg.Options);
var diagnostics = new List <Diagnostic>();
try
{
var(templates, imports, invalidTemplateErrors, options) = AntlrParse(content, id);
newLG.AddRange(templates);
newLG.Imports = imports;
newLG.Options = options;
diagnostics.AddRange(invalidTemplateErrors);
newLG.References = GetReferences(newLG, newLG.ImportResolver)
.Union(lg.References)
.Union(new List <Templates> {
lg
})
.ToList();
var semanticErrors = new StaticChecker(newLG).Check();
diagnostics.AddRange(semanticErrors);
}
catch (TemplateException ex)
{
diagnostics.AddRange(ex.Diagnostics);
}
catch (Exception err)
{
diagnostics.Add(BuildDiagnostic(err.Message, source: id));
}
newLG.Diagnostics = diagnostics;
return(newLG);
}
public void FunctionWithRepeatedParameters()
{
var functionAst = Fun("add",
Parameters(
Param("a", "int"),
Param("a", "int")
),
BinExpr(Var("a"), Var("a"), "+"),
"int");
var let = Let(
Decls(functionAst),
Seq()
);
var errorCollector = new PrinterErrorListener();
var staticChecker = new StaticChecker(errorCollector);
Assert.IsFalse(let.Accept(staticChecker));
Assert.IsFalse(errorCollector.Count == 0);
}
/// <summary>
/// Compila el codigo que se encuentra en el fichero filename
/// </summary>
/// <param name="filename">El fichero a compilar</param>
/// <param name="typeName">El nombre del tipo que contendra las funciones que se definan</param>
/// <returns>Retorna una lista con los errores que se produjeron</returns>
private IEnumerable <AnalysisError> Compile(string filename, string typeName)
{
var s = new StreamReader(filename);
var stm = new AntlrInputStream(s);;
var lexer = new TigerLexer(stm);
var tokenStream = new CommonTokenStream(lexer);
var parser = new BengalaParser(tokenStream);
parser.ConfigErrorListeners();
var expContext = parser.program();
var contextVisitor = new BuildAstVisitor();
var errorsWarning = parser.Errors;
if (parser.NumberOfSyntaxErrors != 0 || parser.Errors.Any())
{
return(errorsWarning);
}
var astRoot = expContext.Accept(contextVisitor);
var generalScope = new Scope(null);
init = new Inizializator <ILCode>(generalScope);
InitScope(generalScope);
var errorListener = new BengalaBaseErrorListener();
var staticAnalysisVisitor = new StaticChecker(errorListener, generalScope);
astRoot.Accept(staticAnalysisVisitor);
if (GenerateCode && !errorListener.Errors.Any())
{
CreateCode(FileName(filename), typeName, astRoot);
}
return(errorListener.Errors);
}
