public static MAst Compile(AstHelper runtime, ICharStream stream)
{
var lexer = new TigerLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new TigerParser(tokens);
ProgramExpression programExpression = parser.parse();
if (parser.NumberOfSyntaxErrors > 0)
{
IEnumerable <string> errors = from e in parser.Errors
select e.ToString();
throw new SyntaxException(errors);
}
AstHelper helper = runtime.CreateChild(function: true, variables: true, types: true);
programExpression.CheckSemantics(helper);
if (helper.Errors.HasErrors)
{
throw new SemanticException(helper.Errors);
}
return(programExpression.Transform());
}
private static int Compile(string filename)
{
filename = Path.GetFullPath(filename);
ICharStream characters = new ANTLRFileStream(filename);
var lexer = new TigerLexer(characters);
ITokenStream tokens = new CommonTokenStream(lexer);
var parser = new TigerParser(tokens);
//parser.TraceDestination = Console.Out;
var result = parser.program();
if (parser.NumberOfSyntaxErrors > 0 || lexer.Error)
{
return(1);
}
((ProgramNode)result.Tree).CheckSemantics(Scope.DefaultGlobalScope, Scope.DefaultGlobalScope.Reporter);
if (Scope.DefaultGlobalScope.Reporter.Errors.Count > 0)
{
Scope.DefaultGlobalScope.Reporter.PrintErrors(Console.Out);
return(1);
}
var generator = new CodeGenerator(filename);
generator.GenerateCode((ASTNode)result.Tree);
generator.SaveBin();
return(0);
}
public static TigerParser CreateParser(string program)
{
var stream = new ANTLRStringStream(program);
var lexer = new TigerLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new TigerParser(tokens);
return(parser);
}
private static void Main(string[] args)
{
var input = new ANTLRStringStream("if row[0] = 0 then 0");
var lexer = new TigerLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new TigerParser(tokens);
ExpressionNode x = parser.prog();
// Debug();
}
protected AstNode ParseText(string text)
{
var s = new StreamReader(GenerateStreamFromString(text));
var stm = new AntlrInputStream(s);;
var lexer = new TigerLexer(stm);
var tokenStream = new CommonTokenStream(lexer);
var parser = new TigerParser(tokenStream);
var expContext = parser.program();
var contextVisitor = new BuildAstVisitor();
return(expContext.Accept(contextVisitor));
}
public static int Compile(string inputPath, string outputPath)
{
try
{
ANTLRFileStream input = new ANTLRFileStream(inputPath);
//LexicalAnalysis
TigerLexer lexer = new TigerLexer(input);
CommonTokenStream tokenStream = new CommonTokenStream(lexer);
//SintaxAnalysis
TigerParser parser = new TigerParser(tokenStream); //Use tokens obtained by lexer
parser.TreeAdaptor = new ASTFactory(); //Use my ASTFactory
TigerParser.tiger_program_return tigerProgram = parser.tiger_program();
//**Check lexical and sintax errors
if (lexer.Errors.Count == 0 && parser.Errors.Count == 0)
{
//SemanticAnalysis
List <Error> semanticErrors = new List <Error>();
SymbolTable symbolTable = new SymbolTable();
InstructionNode decoratedExpr = tigerProgram.Tree as InstructionNode;
decoratedExpr.CheckSemantic(semanticErrors, symbolTable);
if (semanticErrors.Count == 0)
{
TypeExpression programReturnType = decoratedExpr.ReturnType.PrimitiveType;
if (programReturnType is BuiltInType || programReturnType is NilType)
{
ProgramGenerator.BuildTigerProgram(outputPath, decoratedExpr);
return(ReportCompilationSuccesful(inputPath));
}
string message = "If program isn't a valueless expression its return type has to be a built-in type";
semanticErrors.Add(new Error(message, decoratedExpr.Line, decoratedExpr.CharPositionInLine));
}
return(ReportCompilationFailed(semanticErrors));
}
IEnumerable <Error> antlrErrors = lexer.Errors.Union(parser.Errors);
return(ReportCompilationFailed(antlrErrors));
}
catch (Exception e)
{
IEnumerable <Error> exeption = new[] { new Error(e.Message, 0, 0, ErrorKind.UserError) };
return(ReportCompilationFailed(exeption));
}
}
public static ProgramNode ParseInput(string inputPath)
{
try
{
ANTLRFileStream input = new ANTLRFileStream(inputPath);
TigerLexer lexer = new TigerLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
TigerParser parser = new TigerParser(tokens);
parser.TreeAdaptor = new Adaptor();
var program = (ProgramNode)parser.program().Tree;
return(program);
}
catch (ParsingException exc)
{
Console.WriteLine("({1},{2}): {0}", exc.Message, exc.RecognitionError.Line, exc.RecognitionError.CharPositionInLine);
Environment.ExitCode = (int)ErrorCode.Error;
return(null);
}
}
private static void Debug()
{
string[] files =
Directory.GetFiles(@"C:\HERE\School\!4to\Complementos de Compilacion\Compilador\Test cases\Others",
"*.tig");
syntax_error = new List<string>();
syntax_error.Add("appel_test49.tig");
syntax_error.Add("comment_not_ended_before_program.tig");
syntax_error.Add("break_out_of_for"); //No ponen nada dentro del let-in
int errorsCount = 0;
foreach (string file in files) {
if (HasSyntaxError(file)) {
continue;
}
// Console.WriteLine(string.Format("Testing file: {0}", file));
var input = new ANTLRFileStream(file);
var lexer = new TigerLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new TigerParser(tokens);
ExpressionNode x = parser.prog();
if (parser.Errors.Count > 0) {
Console.WriteLine(string.Format("Error in file: {0}", file));
errorsCount++;
foreach (string error in parser.Errors) {
Console.WriteLine(string.Format("Error: {0}", error));
}
// Console.ReadLine();
}
// else
// {
// Console.WriteLine("OK!");
// }
}
Console.WriteLine(string.Format("Done. Errors: {0}", errorsCount));
Console.ReadLine();
}
static Node ParseInput(string inputPath)
{
try
{
var input = new AntlrFileStream(inputPath);
var lexer = new TigerLexer(input);
var errors = new List <string>();
lexer.RemoveErrorListeners();
lexer.AddErrorListener(new LexerErrorListener(errors));
var tokens = new CommonTokenStream(lexer);
var parser = new TigerParser(tokens);
parser.RemoveErrorListeners();
parser.AddErrorListener(new ParserErrorListener(errors));
IParseTree tree = parser.compileUnit();
if (errors.Any())
{
Console.WriteLine();
foreach (var error in errors)
{
Console.WriteLine(error);
}
return(null);
}
var astBuilder = new ASTBuilder();
Node ast = astBuilder.Visit(tree);
return(ast);
}
catch (Exception e)
{
Console.Error.WriteLine(e.Message);
return(null);
}
}
/// <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);
}
private static int Main(string[] args)
{
Console.WriteLine("Tiger Compiler version 1.0");
Console.WriteLine(@"Copyright (C) 2015-2016 Laila González Fernández & Mario César Muñiz Jiménez");
//Creating report, parser and lexer
var arg = args[0];
var report = new Report();
var characters = new ANTLRFileStream(arg);
var lexer = new TigerLexer(report, characters);
var tokens = new CommonTokenStream(lexer);
var parser = new TigerParser(report, tokens)
{
TraceDestination = Console.Out,
TreeAdaptor = new TreeAdaptor()
};
//Syntactic analysis
var ret = (ProgramNode)parser.program().Tree;
if (!report.IsOk)
{
foreach (var message in report)
{
Console.WriteLine($"({message.Line}, {message.Column}): {message.Text}");
}
return(1);
}
//Preparing assembly
var name = Path.GetFileNameWithoutExtension(arg);
var filename = name + ".exe";
var assemblyName = new AssemblyName(name);
var assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave);
var moduleBuilder = assembly.DefineDynamicModule(name, filename);
var programType = moduleBuilder.DefineType(name + ".Program", TypeAttributes.Public);
var mainMethod = programType.DefineMethod("Main", MethodAttributes.Static | MethodAttributes.Public, typeof(void), Type.EmptyTypes);
var generator = mainMethod.GetILGenerator();
assembly.SetEntryPoint(mainMethod);
ProgramNode.Module = moduleBuilder;
ProgramNode.Program = programType;
//Semantic analysis
ret.CheckSemantics(new TigerScope(programType), report);
if (!report.IsOk)
{
foreach (var message in report)
{
Console.WriteLine($"({message.Line}, {message.Column}): {message.Text}");
}
return(1);
}
generator.BeginExceptionBlock();
//Code generation
ret.GenerateCode(generator);
if (!TigerType.AreOfSameType(ret.TigerType, TigerType.Void))
{
generator.Emit(OpCodes.Pop);
}
generator.BeginCatchBlock(typeof(Exception));
generator.BeginScope();
LocalBuilder exception = generator.DeclareLocal(typeof(Exception));
MethodInfo writeLineSO = typeof(TextWriter).GetMethod("WriteLine", new Type[] { typeof(string), typeof(object) });
MethodInfo writeLineS = typeof(TextWriter).GetMethod("WriteLine", new Type[] { typeof(string) });
MethodInfo standardErrorOutput = typeof(Console).GetProperty("Error").GetGetMethod();
generator.Emit(OpCodes.Stloc, exception);
generator.Emit(OpCodes.Call, standardErrorOutput);
generator.Emit(OpCodes.Ldstr, "Exception of type '{0}' was thrown.");
generator.Emit(OpCodes.Ldloc, exception);
generator.Emit(OpCodes.Callvirt, typeof(Exception).GetMethod("GetType", Type.EmptyTypes));
generator.Emit(OpCodes.Callvirt, typeof(Type).GetProperty("Name").GetGetMethod());
generator.Emit(OpCodes.Callvirt, writeLineSO);
generator.Emit(OpCodes.Call, standardErrorOutput);
generator.Emit(OpCodes.Ldloc, exception);
generator.Emit(OpCodes.Callvirt, typeof(Exception).GetProperty("Message").GetGetMethod());
generator.Emit(OpCodes.Callvirt, writeLineS);
generator.EndScope();
generator.Emit(OpCodes.Ldc_I4_1);
generator.Emit(OpCodes.Call, typeof(Environment).GetMethod("Exit"));
generator.EndExceptionBlock();
generator.Emit(OpCodes.Ret);
programType.CreateType();
assembly.Save(filename);
return(0);
}
/// <summary>
/// Compiles a Tiger source code
/// </summary>
/// <param name="input">Source code input</param>
/// <returns>True if compilation proccess succeded, False otherwise</returns>
private static bool Compile(ICharStream input)
{
///limpiamos los errores antes del proceso de compilación
Errors = new List <CompileError>();
///creamos el lexer
Lexer = new TigerLexer(input);
///creamos los tokens
Tokens = new CommonTokenStream(Lexer);
///creamos el parser
Parser = new TigerParser(Tokens);
Parser.TreeAdaptor = new TigerAdaptor();
try
{
///análisis sintáctico
Lexer.OnLexicalErrorOcurrence += NotifyLexicError;
Parser.OnParsingErrorOcurrence += NotifySyntacticError;
Ast = Parser.program().Tree as ExpressionNode;
///en caso de que no fuera un ExpressionNode
if (Ast == null)
{
throw new Exception("A parsing error ocurred");
}
///en caso de haber errores sintácticos
if (Errors.Count > 0)
{
return(false);
}
///creamos la tabla de símbolos
SemanticSymbolTable = new SymbolTable();
///análisis semántico
Ast.CheckSemantic(SemanticSymbolTable, Errors);
///en caso de haber errores semánticos
if (Errors.Count > 0)
{
return(false);
}
///generamos código
CodeGenerator = new ILCodeGenerator(ExecutableFileName, ParentDirectory);
CodeGenerator.OnBuildingErrorOcurrence += NotifyBuildError;
Ast.GenerateCode(CodeGenerator);
///si el Ast retorna valor, lo sacamos de la pila
if (Ast.NodeInfo.BuiltInType.IsReturnType())
{
CodeGenerator.ILGenerator.Emit(OpCodes.Pop);
}
///salvamos el ejecutable
return(CodeGenerator.SaveExecutable());
}
catch (RecognitionException re)
{
///elaboramos el mensaje de error
string errorMessage = Lexer.GetErrorMessage(re, Lexer.TokenNames);
///agregamos el error sintáctico(aunque esto es en caso de que el parser explote)
Errors.Add(new CompileError
{
Line = re.Line,
Column = re.CharPositionInLine,
ErrorMessage = errorMessage,
Kind = ErrorKind.Lexic
});
return(false);
}
catch (Exception e)
{
//change
Errors.Add(new CompileError
{
Line = 0,
Column = 0,
ErrorMessage = "Compile process terminated due to unexpected error",
Kind = ErrorKind.Build
});
return(false);
}
}
