1. Georgia Institute of Technology Speed part 3 Barb Ericson Georgia Institute of Technology May 2006

2. Georgia Institute of Technology Learning Goals Computing Concepts –Write a compiler for a simple graphical language –Extend the compiler –Understand why compiled code is faster than interpreted code

3. Georgia Institute of Technology Writing a Compiler To write a graphics compiler we need to –Write the code for a java class that draws the picture for the given graphics commands We need to start the class definition including starting the main method – the prologue Then we need to open the input file and output a line per command in the main Then we need to finish the main method and class definition – the epilogue

4. Georgia Institute of Technology Creating a Graphics Compiler import java.io.*; /** * Class that reads in a file of graphics instructions, and * then generates a NEW Java Program that * does the same thing as the instructions. Default picture size is 640x480. * * Format of the file is a bunch of lines of the form: * Command X Y * Commands are "line" with parameters of end X,Y and * "circle" with a parameter of diameter. * * For example: * line 10 10 50 70 * circle 10 20 30 * * Which draws a line from (10,10) to (50,70) and a circle at (10,20) * with a diameter of 30. * * @author Barb Ericson * @author Mark Guzdial */

5. Georgia Institute of Technology Start of Class and writePrologue public class GraphicsCompiler { /** Method to write out the prologue for the new program: * All the imports, the class definition, main, etc. * @param file BufferedWriter to write the prologue to **/ public void writePrologue(BufferedWriter file){ try { // Write out the prologue lines file.write("import java.awt.*;"); file.newLine(); file.write("public class GeneratedDrawing{"); file.newLine(); file.write(" public static void main(String args[]){"); file.newLine(); file.write(" Picture frame = new Picture(640,480);"); file.newLine(); file.write(" Graphics g = frame.getGraphics();"); file.newLine(); file.write(" g.setColor(Color.black);"); file.newLine();} catch (Exception ex) { System.out.println("Error during write of prologue"); }

6. Georgia Institute of Technology writeEpilogue Method /** Method to write out the epilogue for the new program: * Show the picture. Close the main and the class. * @param file BufferedWriter to write the epilogue to **/ public void writeEpilogue(BufferedWriter file){ try { // Write out the epilogue lines file.write(" frame.show();"); file.newLine(); file.write(" } // end main()"); file.newLine(); file.write("} // end class"); file.newLine();} catch (Exception ex) { System.out.println("Error during write of epilogue"); }

7. Georgia Institute of Technology Start of CompileCommands Method /** * Method to compile the commands in the given file */ public void compileCommands(String fileName) { String line = null; String [] params = null; int x1, y1, x2, y2, diameter; // try the following try { // read from the file BufferedReader reader = new BufferedReader(new FileReader(fileName)); BufferedWriter writer = new BufferedWriter(new FileWriter( FileChooser.getMediaPath("GeneratedDrawing.java"))); writePrologue(writer);

8. Georgia Institute of Technology Loop and handle line command // loop till end of file while ((line = reader.readLine()) != null) { // what command is this? if (line.startsWith("line")) { // Get the parameters for drawing the line params = line.split(" "); // params[0] should be "line" x1 = Integer.parseInt(params[1]); y1 = Integer.parseInt(params[2]); x2 = Integer.parseInt(params[3]); y2 = Integer.parseInt(params[4]); // Now, write the line that will LATER // draw the line writer.write(" g.drawLine("+x1+","+y1+","+x2+","+y2+");"); writer.newLine(); }

9. Georgia Institute of Technology Handle circle command else if (line.startsWith("circle")) { // Get the parameters for drawing the circle params = line.split(" "); // params[0] should be "circle" x1 = Integer.parseInt(params[1]); y1 = Integer.parseInt(params[2]); diameter = Integer.parseInt(params[3]); // Now, draw the circle in writer.write(" g.drawOval("+x1+","+y1+","+diameter+","+ diameter+");"); writer.newLine(); }

10. Georgia Institute of Technology Finish compileCommand Method else { System.out.println("Uh-oh! Invalid command! "+line); return;} } writeEpilogue(writer); writer.close(); } catch (FileNotFoundException ex) { System.out.println("Couldn't find file " + fileName); fileName = FileChooser.pickAFile(); compileCommands(fileName); } catch (Exception ex) { System.out.println("Error during read or write"); ex.printStackTrace(); }

11. Georgia Institute of Technology Main for Testing public static void main(String[] args) { GraphicsCompiler compiler = new GraphicsCompiler(); String fileName = FileChooser.getMediaPath( "graphics-commands.txt"); compiler.compileCommands(fileName); } } // end class

12. Georgia Institute of Technology How it Works Open the same file for input as the interpreter –But don't create a blank picture to write to –Instead write to GeneratedDrawing.java Write out a class definition And a main that creates the blank picture, gets the graphics context on that picture, and does the drawing. Compile GeneratedDrawing and execute it to see the picture

13. Georgia Institute of Technology Exercise Add the code to handle triangles to the GraphicsCompiler class –triangle x1 y1 x2 y2 x3 y3 It will draw a triangle with points at (x1,y1), (x2,y2), and (x3, y3)

14. Georgia Institute of Technology Compilers Compilers still have to interpret the language they are compiling –But, they only do this one time When you compile –Then you can execute the compiled code many times Applications like Word or Photoshop are written in C or C++ and then compiled to machine language programs –The generated machine language program is faster than an interpreted one

15. Georgia Institute of Technology Summary Compilers read a language and output the required code in another language –Like from our graphical language to Java commands –Or from C to machine language You compile code once to turn it into the desired language –You can run the compiled code many times Running compiled code is faster than running code that must be interpreted