/**
* Initializes a program.
*
* @return program
*/
private static Program initProgram() {
Program program = new Program();
program.state().reset();
program.initBytecodeReader(new BytecodeParser());
initParser(program);
return program;
}
@Override
public void visitar(Program program) {
// obtengo el identificador dl primer nodo.
String ident = program.toGrapher(this.cantNodosVisitados);
// agrego el identificador al codigo.
this.codigoGraph += ident;
// sepero el nombre del identificador del nombre asignadodentro del nodo, posicion 0.
String[] delimitador = ident.split("\\[");
// obtengo la id del nodo 'sin el ;'.
this.auxPadres.push(delimitador[0]);
// cuento como nodo visitado.
this.cantNodosVisitados++;
// obtengo la lista de declaraciones dentro del nodo Program.
ArrayList<Nodo> lista = program.getDeclaraciones();
// visito los siguientes nodos (hijos).
for (Nodo nodo : lista) {
nodo.aceptar(this);
}
// elimino el padre actual.
this.auxPadres.pop();
try {
this.generarGraph();
} catch (Exception ex) {
ex.printStackTrace();
}
}
/** Returns the weakest precondition of a given program. */
@Override
public Term visit(Program root) {
visitMethod = false;
int lines = root.getNumberOfChildren();
for (int i = 0; i < lines; i++) {
root.getChild(lines - i - 1).accept(this);
}
return wp;
}
/**
* @param artifact artifact to create program from
* @return ASTNodeArtifact
*/
public static ASTNodeArtifact createProgram(final ASTNodeArtifact artifact) {
assert (artifact.astnode != null);
assert (artifact.astnode instanceof Program);
Program old = (Program) artifact.astnode;
Program program;
try {
program = old.clone();
} catch (CloneNotSupportedException e) {
program = new Program();
}
ASTNodeArtifact p = new ASTNodeArtifact(program);
p.deleteChildren();
return p;
}
/**
* Constructs an ASTNodeArtifact from a FileArtifact.
*
* @param artifact file artifact
*/
public ASTNodeArtifact(final FileArtifact artifact) {
assert (artifact != null);
setRevision(artifact.getRevision());
ASTNode<?> astnode;
if (artifact.isEmptyDummy()) {
astnode = new ASTNode<>();
setEmptyDummy(true);
} else {
Program p = initProgram();
p.addSourceFile(artifact.getPath());
astnode = p;
}
this.astnode = astnode;
renumber(1, this);
}
/**
* Initializes parser.
*
* @param p program
*/
private static void initParser(final Program p) {
p.initJavaParser(
new JavaParser() {
@Override
public CompilationUnit parse(final java.io.InputStream is, final String fileName)
throws java.io.IOException, beaver.Parser.Exception {
return new parser.JavaParser().parse(is, fileName);
}
});
}
/**
* This is the primary method in this file. It returns a map from Strings to Integers. The string
* keys are in the form: "ClassName.MethodName" The values of the map are simply how many local
* variables the method uses, excluding local parameter variables.
*
* @param ast - The program's abstract syntax tree
* @return the map described above.
*/
public Map<String, Integer> getNumLocalVars(Program ast) {
// clears the map
this.numLocalVars.clear();
// Populates the map appropriately
ast.accept(this);
// Return the map
return this.numLocalVars;
}
public void run() {
try {
Scanner s = new Scanner(this.reader);
Parser p = new Parser(s);
Symbol root = p.parse();
Program prog = (Program) root.value;
prog.accept(new PrettyPrintVisitor());
System.out.print("Parser rodou com sucesso!");
} catch (CompilerException e) {
// erro de compilação do arquivo de entrada
System.err.println(e.getMessage());
} catch (Exception e) {
// erro do compilador
System.err.println("Erro inesperado no parser: " + e.toString());
e.printStackTrace();
}
}
@Override
public void visit(Program prog) {
if (prog == null) return;
if (prog.getMainClass() != null) prog.getMainClass().accept(this);
if (prog.getClassDeclList() == null) return;
for (int i = 0; i < prog.getClassDeclList().size(); i++) {
if (prog.getClassDeclList().elementAt(i) == null) continue;
System.out.println();
prog.getClassDeclList().elementAt(i).accept(this);
}
}
public void callMetaobjects(String filename, Program program, PrintWriter outError) {
boolean foundCE = false;
boolean foundNCE = false;
for (MetaobjectCall moCall : program.getMetaobjectCallList()) {
if (moCall.getName().equals("ce")) {
this.numSourceFilesWithErros++;
String message = (String) moCall.getParamList().get(2);
int lineNumber = (Integer) moCall.getParamList().get(0);
if (!program.hasCompilationErrors()) {
// there was no compilation error. There should be no call
// @ce(...)
// the source code, through calls to "@ce(...)", informs
// that
// there are errors
String whatToCorrect = "";
if (moCall.getParamList().size() >= 4) {
whatToCorrect = (String) moCall.getParamList().get(3);
whatToCorrect = " (" + whatToCorrect + ")";
}
this.shouldButWereNotList.add(
filename + ", " + lineNumber + ", " + message + whatToCorrect);
if (foundCE)
outError.println(
"More than one 'ce' metaobject calls in the same source file '" + filename + "'");
foundCE = true;
} else {
// there was a compilation error. Check it.
int lineOfError = program.getCompilationErrorList().get(0).getLineNumber();
String ceMessage = (String) moCall.getParamList().get(2);
String compilerMessage = program.getCompilationErrorList().get(0).getMessage();
if (lineNumber != lineOfError) {
String whatToCorrect = "";
if (moCall.getParamList().size() >= 4) {
whatToCorrect = (String) moCall.getParamList().get(3);
whatToCorrect = "(" + whatToCorrect + ")";
}
this.wereButWrongLineList.add(
filename
+ "\n"
+ " correto: "
+ lineNumber
+ ", "
+ ceMessage
+ " "
+ whatToCorrect
+ "\n"
+ " sinalizado: "
+ lineOfError
+ ", "
+ compilerMessage);
} else {
// the compiler is correct. Add to correctList the
// message
// that the compiler signalled and the message of the
// test, given in @ce
correctList.add(
filename
+ "\r\n"
+ "The compiler message was: \""
+ compilerMessage
+ "\"\r\n"
+ "The 'ce' message is: \""
+ ceMessage
+ "\"\r\n");
}
}
} else if (moCall.getName().equals("nce")) {
if (foundNCE)
outError.println(
"More than one 'nce' metaobject calls in the same source file '" + filename + "'");
foundNCE = true;
if (program.hasCompilationErrors()) {
int lineOfError = program.getCompilationErrorList().get(0).getLineNumber();
String message = program.getCompilationErrorList().get(0).getMessage();
this.wereButShouldNotList.add(filename + ", " + lineOfError + ", " + message);
}
}
}
if (foundCE && foundNCE)
outError.println(
"Calls to metaobjects 'ce' and 'nce' in the same source code '" + filename + "'");
}
/**
* @param args
* @param stream
* @param numChRead
* @param outError
* @param printWriter
* @throws IOException
*/
private void compileProgram(File file, String filename, PrintWriter outError) {
Program program;
FileReader stream;
int numChRead;
try {
stream = new FileReader(file);
} catch (FileNotFoundException e) {
String msg = "Something wrong: file does not exist anymore";
outError.println(msg);
return;
}
// one more character for '\0' at the end that will be added by the
// compiler
char[] input = new char[(int) file.length() + 1];
try {
numChRead = stream.read(input, 0, (int) file.length());
if (numChRead != file.length()) {
outError.println("Read error");
stream.close();
return;
}
stream.close();
} catch (IOException e) {
String msg = "Error reading file " + filename;
outError.println(msg);
try {
stream.close();
} catch (IOException e1) {
}
return;
}
Compiler compiler = new Compiler();
program = null;
// the generated code goes to a file and so are the errors
program = compiler.compile(input, outError);
callMetaobjects(filename, program, outError);
if (!program.hasCompilationErrors()) {
String outputFileName;
int lastIndex;
if ((lastIndex = filename.lastIndexOf('.')) == -1) lastIndex = filename.length();
outputFileName = filename.substring(0, lastIndex);
if ((lastIndex = filename.lastIndexOf('\\')) != -1)
outputFileName = filename.substring(lastIndex + 1);
FileOutputStream outputStream;
try {
outputStream = new FileOutputStream(outputFileName + ".c");
} catch (IOException e) {
String msg = "File " + outputFileName + " was not found";
outError.println(msg);
return;
}
PrintWriter printWriter = new PrintWriter(outputStream);
PW pw = new PW();
pw.set(printWriter);
program.genC(pw);
if (printWriter.checkError()) {
outError.println("There was an error in the output");
}
printWriter.close();
}
}
public static void main(String[] args) {
try {
if (args.length == 2) {
FileReader reader = new FileReader(args[1]);
scanner s = new scanner(reader);
parser p = new parser(s);
Symbol root;
root = p.parse();
if (args[0].equalsIgnoreCase("-ts")) {
System.out.println("\n\n--------------------" + args[1] + "-------------------");
System.out.println("Gerando tabela de simbolos...");
Program program = (Program) root.value;
VisitorTableSymbol vi = new VisitorTableSymbol();
program.accept(vi);
if (vi.getError().size() > 0) {
vi.showErrors();
} else vi.showAllTable();
System.out.println("Concluido!");
} else {
if (args[0].equalsIgnoreCase("-sa")) {
System.out.println("\n\n--------------------" + args[1] + "-------------------");
System.out.println("Gerando tabela de simbolos...");
Program program = (Program) root.value;
VisitorTableSymbol vi = new VisitorTableSymbol();
program.accept(vi);
vi.showErrors();
// vi.showAllTable();
if (vi.getError().size() == 0) {
System.out.println("Efetuando a analise semantica...");
VisitorSemanticAnalysis vis = new VisitorSemanticAnalysis(vi);
program.accept(vis);
vis.showErrors();
if (vis.getError().size() == 0)
System.out.println("Analise semantica efetuada com sucesso!");
}
} else {
if (args[0].equalsIgnoreCase("-gc")) {
System.out.println("\n\n--------------------" + args[1] + "-------------------");
System.out.println("Gerando tabela de simbolos...");
Program program = (Program) root.value;
VisitorTableSymbol vi = new VisitorTableSymbol();
program.accept(vi);
vi.showErrors();
if (vi.getError().size() == 0) {
System.out.println("Efetuando a analise semantica...");
VisitorSemanticAnalysis vis = new VisitorSemanticAnalysis(vi);
program.accept(vis);
vis.showErrors();
if (vis.getError().size() == 0) {
VisitorGenCod vigc = new VisitorGenCod(args[1], vi);
program.accept(vigc);
System.out.println("Compilacao efetuada com sucesso!");
}
}
}
}
}
} else {
if (args.length == 1) {
if (args[0].equalsIgnoreCase("-all")) {
String[] files = {
"BinarySearch",
"BinaryTree",
"BubbleSort",
"Factorial",
"LinearSearch",
"LinkedList",
"QuickSort",
"TreeVisitor"
};
for (int i = 0; i < files.length; i++) {
FileReader reader1 =
new FileReader("SamplePrograms\\SampleMiniJavaPrograms\\" + files[i] + ".java");
System.out.println(
"\n\n--------------------" + files[i] + ".java" + "-------------------");
scanner s = new scanner(reader1);
parser p = new parser(s);
Symbol root;
// replace p.parse() with p.debug_parse() in next line to see trace of
// parser shift/reduce actions during parse
root = p.parse();
Program program = (Program) root.value;
VisitorTableSymbol vi = new VisitorTableSymbol();
program.accept(vi);
vi.showAllTable();
if (vi.getError().size() == 0) {
VisitorSemanticAnalysis vis = new VisitorSemanticAnalysis(vi);
program.accept(vis);
vis.showErrors();
if (vis.getError().size() == 0) {
VisitorGenCod vigc = new VisitorGenCod(files[i], vi);
program.accept(vigc);
System.out.println("Compilacao efetuada com sucesso!");
}
}
}
System.out.println("Todas as tentativas ou sucessos de compilacao foram concluidos!");
}
} else System.out.println("Por favor informe um argumento valido!");
}
} catch (Exception e) {
// yuck: some kind of error in the compiler implementation
// that we're not expecting (a bug!)
System.err.println("Unexpected internal compiler error: " + e.toString());
// print out a stack dump
e.printStackTrace();
}
}
public Object visit(Program node) {
return layoutNary("Program", node.getClassList());
}
