KU Compilerbau - Programming Assignment

Transcription

1 KU Compilerbau - Programming Assignment Univ.-Prof. Dr. Franz Wotawa, Birgit Hofer Institute for Software Technology, Graz University of Technology April 20, 2011 Introduction During this semester you will build a simple C compiler in Java using ANTLR 3.3. You can to this together with 3 of your colleagues (4 students per group at maximum). Your compiler should be able to translate a program written in the simplified C language described below to Java bytecode. Figure 1(b) illustrates the different phases of a compiler. The phases which will be part of your exercise are highlighted in Grey. (a) Language processing system (b) Compiler phases Figure 1: Compiler 1

2 The following table gives an overview of your tasks and the delivery deadlines of them. Task Reachable Points Deadline 0 Group Registration Lexical Analysis Syntax Analysis Type Checking Intermediate Code Code Generation General rules You have to deliver tasks 1-5 via SVN. You must always hand in something, since the tasks build on the previous tasks. If you are not able to solve one of the tasks you will get the source code of another group on request so that you are able to finish the other tasks. You must document the percentage of participation of each team member for each task in the README file. You will get the points reached for each task via . There are mandatory interviews at the end of task 5. File/folder hierarchy Your SVN repository must have a branch for each task. The branches must have the name task {number} where {number} is replaced by the actual task number. Each branch must have the following structure. Please take care that the required documents are in the correct folders. task {number}/ build.xml doc/ lib/ src/ test/ readme.txt readme.txt **/*.java NEW: SimpleC.g The file readme.txt must contain the table with the percentage of participation all changes made (e.g. bug correction) with respect to the previous tasks in clear and short sentences known limitations / bugs implemented additional tasks 2

3 lib The directory lib should contain the ANTLR and the JUnit.jar files. build.xml The file build.xml must define an ant task compile which compiles the grammar-file to Java files and compiles all Java files from src. an ant task run-junit which depends on compile, compiles all Java files from test, runs all JUnit tests and creates an xml file in the output folder. You can use the BUILD file from the framework. Framework You can download a simple framework from course web site. This framework contains all required libraries (ANTLR, JUnit ), skeletons of the required classes, JUnit test files, example input and output files, an example README file and an example BUILD file. Upload these files to your repository and modify and extend them. 3

4 The Grammar Syntax program declarations function declarations declarations declarations type identifier-list; declarations function head; ɛ identifier list identifier identifier-list, identifier identifier id * identifier type int char void function declarations function declaration function declarations ɛ function declaration function head function body function head type identifier arguments arguments ( parameter-list ) ( ) parameter list type identifier parameter list, type identifier function body { declarations optional statements } compound statement { optional statements } optional statements statement list ɛ statement list statement statement list statement statement compound statement if (assignment expr) statement else statement for (expr stmt expr stmt assignment expr) statement expr stmt return assignment expr ; expr stmt ; assignment expr ; assignment expr identifier assignop expression identifier assignop & identifier expression expression simple expression simple expression relop assign simple expression simple expression term sign term simple expression sign term simple expression or term term factor term mulop factor factor identifier function call NEW: int ( assignment expr ) not factor literal string function call identifier ( extend assignment expr list ) identifier ( ) extend assignment expr list assignment expr & identifier extend assignment expr list, assignment expr extend assignment expr list, & identifier relop assign relop 4

5 assignop Operators relop < <= > >= == sign + - mulop * / % && assignop = or not! Identifiers id letter ( letter digit )* letter [a-za-z] digit [0-9] String literals literal string ( [ 0-9a-zA-Z ]! % escape sequence relop sign mulop assignop )* Numerical literals int decint octint hexint decint 0 digit digit0* hexint 0 (x X) hexdigit+ octint 0 octdigit+ digit [1-9] digit0 [0-9] hexdigit [0-9a-fA-F] octdigit [0-7] Escape sequences \ n newline \ t horizontal tab \ b backspace \ r carriage return \ f form feed \ single quote \ double quote \\ backslash Comments Comments may appear after any token and are surrounded by /* and */. White spaces White spaces between tokens are optional, with one exception: keywords must be surrounded by white spaces, newlines or the beginning of the program. 5

6 0 Group Registration Groups up to 4 students are allowed. In order to get access to an SVN repository you have to register your group with help of the Web-Interface. The link to the Web-Interface will be posted on Wednesday, March 16 th to the newsgroup. 1 Lexical Analysis Write a lexical analyzer for the subset of the C language described above in Java with ANTLR version 3.3. Name your grammar file NEW: SimpleC.g. Create the class LexicalAnalyzer.java in the package at.tugraz.ist.compilerbau in the directory src with the method public static int lexer(string file path). This method returns 0 if the lexical analysis was successful, otherwise it returns the number of errors found. In addition write the following information to the standard output: Input program abstracted to lexemes and keywords with the same line separations as the original program, line numbers added, all comments and unnecessary white spaces removed, Summary or errors Number of errors found in the source file You can find an example input and output in the framework. Create your own example programs (at least one error-free program and one program which leads to lexical errors) and add them to the test-folder. Extend the JUnit test to test those programs. Create the README file as descripted above and extend the BUILD file if necessary. Task Summary 1. Define an ANTLR grammar file for the shown grammar 2. Implement the requested method for the class LexicalAnalyzer 3. Create example programs and extend the JUnit tests 4. Create a README file 5. Adapt the BUILD file if necessary 6

7 2 Syntax Analysis Write a syntactical analyzer for the grammar described above in Java with ANTLR version 3.3. Extend the file NEW: SimpleC.g. Please note: the grammar above must be transformed into an LL grammar. Create the class SyntaxAnalyzer.java in the package at.tugraz.ist.compilerbau in the directory src with the method public static int checksyntax(string file path). This method returns 0 if the syntax analysis was successful, otherwise it returns the number of errors found. If there exist lexer errors, no syntactical analysis have to be performed. Instead the number of lexical errors should be returned. In addition write the following information to the standard output: Input program abstracted to function definitions a line for every definition of a function/procedure (name + signature) an output for the end of every function/procedure line numbers added Summary or errors Number of errors found in the source file You can find an example input and output in the framework. Create your own example programs (at least one error-free program and one program which leads to syntactical errors) and add them to the test-folder. Extend the JUnit test to test those programs. It makes sense to build an abstract syntax tree, since you need it for the next task. Be careful with left and right associativity and precedence. An operator like + is left-associative: a + b + c is equal to (a + b) + c, but assignment is right-associative: a = b = c means a = (b = c). Update the your README file. Don t forget to document any changes in the lexer you made in this task. Bonus Task Your are allowed to extend the given grammar, e.g., you can add in-line comments. If you extend the language, please make sure that your grammar stays downward compatible, and document your changes in the README file. You can get up to 3 points for extensions. Task Summary 1. Extend your ANTLR grammar file 2. Implement the requested method for the class SyntaxAnalyzer 3. Create example programs and extend the JUnit tests 4. Adapt the README file 7

8 3 Type Checking Create data structures to hold the type information for the identifiers. You will have (at least) int, void, pointers to (pointers to pointers to... ) int or void, and functions with argument and return types. Implement the code to fill the data structures, and to perform type checking. Create the class TypeChecker.java in the package at.tugraz.ist.compilerbau in the directory src with the method public static int checktypes(string file path). This method returns 0 if the type checking analysis was successful, otherwise it returns the number of errors found. If there exist lexical or syntactical errors, no type checking have to be performed. Instead the number of lexical or syntactical errors should be returned. In addition write the following information to the standard output: Type errors Use of undeclared identifiers Use of incorrect type Double declarations (Note: It is allowed to declare a variable in the global scope and in each local scope. But it is an error to declare a variable more than once in any given scope.) Type coercions All type coercions. (For example: cast expression 4 * a from int to real in line 27. ) The type of any operator. (For example, real-real addition * a in line 27.) Definitions of variables, including type and scope. defined in function f with type integer ). (For example: variable a Keep your output readable, e.g., in the form of a table. You can find an example input and output in the framework. The examples shown here do not prescribe the exact form of your output. Define printf and scanf now. Note that printf may have one or two arguments. Create your own example programs (at least one type-correct and one type-incorrect program) and add them to the test-folder. Extend the JUnit test to test those programs. Scopes Note that there are two scopes: a global one for the program and a local one for the current function. Nested scoping is not required, but you can get bonus points for implementing it. NEW: Forward declarations In C it is not allowed to use a variable before it is defined. For instance, if you define a function a, and then a global variable q, you can not use q in a. For functions, the situation is more complicated. If you define a function a, and then a function b, and you use b in a, you are creating an implicit declaration, which assumes, that b returns value of a certain type, e.g., an int. This problem is avoided in C by forward declarations. Don t forget to include forward declarations in your type checking. Type Coercion A coercion occurs if the type of an operand is automatically converted to the type expected by the operator. 1. A conversion to void is always allowed and results in the result being thrown away. For instance, printf returns an int, but (void) printf("hallo") (not allowed in our grammar), or more succinctly printf("hallo") are legal C statements. 8

9 2. A conversion from void is never possible. A void type may not participate in an operation (such as +). A void variable can not be defined. 3. A binary operator (such as + or <, but not && or ) takes either two int, or a char and an int (in either order). In the latter case, the char is converted to int before the operation is performed. (You can not do arbitrary arithmetic on pointers. In C, adding pointer and int is allowed, but you do not need to support it. Comparison of pointers (a<b) is allowed!) 4. A char can be assigned to an int and is converted automatically. An int can also be converted to a char automatically; this may lead to loss of information. 5. int, char and pointers can be used in Boolean expressions. An int or char with the value 0 is false, any other value is true. Pointers are NULL (false) or non-null (true). Boolean operators (&&,, <, >, etc.) return an int. 6. Any pointer conversion is allowed, and never leads to an error. A warning of an invalid cast is appreciated, and if you implement such warnings consequently, you ll get bonus points. Conversions between pointers and ints are not supported. Bonus Tasks Warnings for invalid pointer casts: 2 points Implementation of nested scopes: 2 points Extend the type system to include more types. Note: coercion rules in C are not quite trivial. Points depend on your exact plans. Don t forget to clearly document the implemented bonus taks in the README file. Task Summary 1. Implement the requested method for the class TypeChecker 2. Define printf and scanf 3. Create example programs and extend the JUnit tests 4. Adapt the README file 9

10 4 Intermediate Code Build an Intermediate Code Generator which is able to build the intermediate code for any program written in our grammar. Create the class IntermediateCode.java in the package at.tugraz.ist.compilerbau in the directory src with the method public static int createintermediatecode(string file path). This method returns 0 if the intermediate code generation was successful, otherwise it returns the number of (lexical, syntactical or type) errors found. In addition it writes the ASCII representation of the intermediate code to the standard output. Use comments to clarify which part of the C code corresponds to the intermediate code. Three-Address Code The three address code should support the following commands: Assigments of the form x := y op z, where op is one of int+, int-, int*, int/, int%, which take two integers and return the corresponding result. int&&, int, which take two integers and return 0 or 1. int<, int<=, int>=, int>, int==, which take two integers and return 0 or 1. Assignments of the form x := op y, where op is one of intminus intnot and y is a variable. op is one of address, dereference and y is a variable. op is one of intconst, pointerconst, and y is an integer constant or a label, respectively. The assignment x *= y, stating that y should be assigned to the location that x points to. (Translates the C statement *x = y.) A constant declaration string a, where a is a quoted string ( hello!\ 0 ). Copy statements: x := y. Jumps The label label L. The unconditional jump goto L, where L is a label Conditional jump ifint x goto L, where x is an int and L a label. For functions The statement param x, which says that x is a parameter to the next function call. Parameters should be listed from right to left. The statement call f n, where f is the name of a function and n is the number of parameters. The statement function f n, where f is a function, and n is the number of local variables, including temporary ones. The statements return and return x, which return from the function, possibly returning the value in x.if you want your compiler to be gcc compatible, you need to distinguish between int and char returns. This is not part of the assignment. The statement local x i, where x is a local variable, a temporary variable, or an argument, and i is a number to reserve space. For locals and temps, i should be negative and run from -1 down. 10

11 For arguments, i should be positive and run from 0 up (the left argument has number 0). The statement getresult x, which stores the return value of the last function call (if any) in x. The statement global x i, where x is a variable name, and i is a number, starting at 0, running up. The statement comment x, which is ignored. This list might be incomplete. Your are allowed to add additional commands. Post your additions to the newsgroup so that others can benefit from them. Don t forget to document your extensions in the README file. You do not have to pay attention to efficiency of time or space. In the intermediate code (but not in C ), every function has to end with a return. Boolean values Truth values are represented by integers: 0 is false, anything else is true. generated by a comparison, &&, or may only be 0 or 1. A truth value Pointers Pointers are treated like ints. Implementation Suggestion Create an inheritance hierarchy, with the class Statement on top. Other Statements inherit from this class. Your intermediate code program is a vector of Statements, each Statement can print itself. Later, each Statement will know how to translate itself to e.g. assembler code or Java bytecode. Use an attributed grammar on the abstract syntax tree to generate the code. A function node, for example, should get the intermediate code from its children (declarations, statements), plus the number of temp variables, so that it can construct the function name number statement. The intermediate code for the function node consists of this statement and the intermediate code for the body. Bonus Task You need not to implement short-circuit evaluation for Boolean expressions. You will get 2 bonus points for implementing short circuiting. Task Summary 1. Implement the requested method for the class IntermediateCode 2. Update your README file 11

12 5 Code Generation Implement the translation of the intermediate code to Java bytecode. Create the class CodeGeneration.java in the package at.tugraz.ist.compilerbau in the directory src with the method public static int createcode(string file path). This method creates the output file <file>.class, where <file>.c is the name of the input file. The method returns 0 if the code generation was successful, otherwise it returns the number of (lexical, syntactical or type) errors found. Your program must be executable by the Java Virtual machine. Printf and scanf must work. NEW: Option Instead of directly producing bytecode, you are allowed to produce code in an assembler-like syntax (Jasmin). In this case your output files must end with.j. It must be possible to translate the generated output files to bytecode by using Jasmin 2.4. Don t forget to add jasmin.jar to your libs-folder. Task Summary 1. Implement the requested method for the class CodeGeneration 2. Update your README file 12