Docstoc

Visual Compiler Compiler

Document Sample
Visual Compiler Compiler Powered By Docstoc
					                    AtoCC Compiler Construction Workshop




                     Creating an Interpreter
                       and Compiler for a
                      music language ML




Aalborg, 26.03.08                                          Michael Hielscher
    Content
2



       Introduction
         Why   we created AtoCC

         What   is AtoCC

       The music language ML

       Create an interpreter for ML

       Create a MLSVG compiler
      Why we created AtoCC ?
3



    1. We want to motivate students to deal with theoretical
       computer science.
        We use Compiler Construction as an interesting topic
       (practical use) right from the beginning.
        We define a target project we want to solve (Compiler).
        Target language is not machine code !!!
    2. Cycles between teaching theory and using it in a practical
       way (project based). The practical part is no add-on at the
       end of theory class!
    3. Students solve complex tasks in the area of theoretical
       computer science with very high abstraction.
    Why we created AtoCC ?
4



       We needed a software package solving this
        task without dealing with too much technical
        stuff.

       We needed software for teaching purposes not
        for professional use.
      Abstraction and problem solving model
5

                       develop Software   use Software

    Computer Science
    based layer



    Model
    based layer




    Problem
    based layer
    What is AtoCC ?
6


     The learning environment AtoCC can be of
      use in teaching abstract automata, formal
      languages, and some of its applications in
      compiler construction.
     From a teacher's perspective AtoCC aims to
      address a broad range of different learning
      activities forcing the students to actively
      interact with the subjects being taught.
     AtoCC contains 6 programs:
      AutoEdit, AutoEdit Workbook, kfG-Edit,
      TDiag, VCC, SchemeEdit                     www.atocc.de
    Software we need today
7




    Please install the following software:
     Java JDK

     Mozilla FireFox as SVG viewer

     AtoCC (www.atocc.de)

     Workshop ZIP file:

      AtoCC Website  A. Education 
      Aalborg  Materials
    The music language ML
8


     Like for mobile phones we can
      find several easy to read
      tone/music languages
     We want to create an own
      primitive note language for
      monophonic songs (only one
      voice)
     Example:
      C1-2 G1-8 A0-4 A0-8
      G0-4 G0-8 C0-8 P-2
    The music language ML
9


     This language is so primitive,
      that it is even a regular
      language.
     A more complex language
      could include loops:
      [C1-2 G1-8 [A0-4 A0-8]] P-2
      (typical bracket example for
      push down automata)
     The music language ML
10


      Play with ML:
      Open folder „Songs“ and execute Console.bat




                                  Task: Change song file content
                                     and get familiar with ML
     Creating an Interpreter
11



        Create an Interpreter for ML
         1)   Define a T-Diagram

         2)   Define a grammar for ML

         3)   Define Scanner and Parser definition

         4)   Create S attributes

         5)   Generate the ML Interpreter compiler

         6)   Test the Interpreter with the help of the T-
                                                        Worksheet 1
              Diagram
     T-Diagrams
12


        We use T-Diagrams to model our compiler
         processes.
        Our diagrams look slightly different:
          We have 4 element types.
          Compiler, Program, Interpreter und E/A for
           Input/Output




             Compiler   Program    Interpreter   Input/Output
     Create a T-Diagram
13


        Note down a T-Diagram for applying our ML
         Interpreter written in JavaBytecode on a
         program written in ML.
     Create a T-Diagram
14
     Define a grammar for ML
15


        One part of our T-Diagram, the Interpreter, we
         want to create now.
        Therefore we need to define how ML looks like
         (Syntax). We use a context free grammar GML
         (in BNF).
        Look at examples and try to figure out a
         grammar:
          G0-4 G1-2 A0-1                Start with:
          D1-32 P-16 A-8 P-2            Song  Notes
          C0-16 C1-8 F0-1 H1-2 P-1
                                         Notes  ?
     Define a grammar for ML
16
     Define a grammar for ML
17
     Define a grammar for ML
18
     Create an Interpreter for ML
19




        Basically we can say that an interpreter is
         similar to a compiler, but without generating
         some target language.

        Therefore we will generate a compiler used as
         an interpreter, which does not output some
         target language.
     How does a compiler work
20




                                For an Interpreter we don’t
                                care for output code,
                                 we want to execute
                                something directly
     Creating an Interpreter from GML
21


        We need to declare a scanner and a parser (a
         description how they shall work).
        We start with a scanner definition.
        We define Token classes with patterns
         (RegExp.)
        Easiest solution: for each terminal of GML we
         use exactly one pattern (one Token class).
        More complex pattern result into a much less
         work for the parser  we shall try to give the
         scanner a job to do 
     Creating an Interpreter from GML
22




              KeyName         all keynames
              C|D|E|F|G|H|A

              Octave          allowed octaves      Token
                                                   class
                1
              0|1                                  list
              Duration        duration values
              1
              1|2|4|8|16|32   (full, half, ¼, …)
     Creating an Interpreter from GML
23


        We need to make sure,       KeyName
         that none token overlaps    C|D|E|F|G|H|A

         the pattern of another.     Token0
                                     0
        But in program
                                     Token1
         languages this is quite     1
         often the case:
                                     Token2_32
         Keyword: begin              2|4|8|16|32

         Identifier: [a-z]+          Minus
                                     \-
        To solve this, the
         ordering of token classes   Pause
                                     P
         in list is important!
     Creating an Interpreter from GML
24


        We can rewrite our grammar to make use of
         our tokens as new terminals:




        We will have 6 token classes with pattern for:
         KeyName, Token0, Token1, Token2_32, P
         and -
       Creating an Interpreter from GML
25


          We can represent such pattern also as
           primitive Finite Automata:


     Token2_32
     2|4|8|16|32

                                         KeyName
                                         C|D|E|F|G|H|A
     Creating an Interpreter from GML
26
     Creating an Interpreter from GML
27




                             We rename the
                             generated token
                             classes to useful
                             names
     Creating an Interpreter from GML
28




                              We need to specify
                              the regular
                              expressions we
                              defined earlier
     Creating an Interpreter from GML
29
     Creating an Interpreter from GML
30


        We can generate an empty compiler (scanner
         + parser) now and apply it on a program in ML:




        We want to generate sound  something is
         still missing 
     Creating an Interpreter from GML
31


        We need to define S attributes for each parser
         rule.
        These attributes are small code fragments that
         are executed when this rule is applied.
        Each rule returns a result $$ by executing the
         code fragment (we need to fill $$).

        Example:
         Note  Key – Duration
         $$ = “Note: “ + $1 + “ Length: “+ $3;
     Creating an Interpreter from GML
32


     The placeholders $1 to $n:
      In S attributes we can use placeholders for the results of

       each rule right side element.
                                                                  C1-4
                                                 Input word: C1-8 D1-4




                                     From a token $n is always the
         $1     $2      $2            input content (lexem)!
         C1      -      8
                                     From a nonterminal $n is always
                                      the result $$ from this element!




         $$ = "C1-8";
     Creating an Interpreter from GML
33


     The placeholders $1 to $n:
      In S attributes we can use placeholders for the results of

       each rule right side element.
                                                                  C1-4
                                                 Input word: C1-8 D1-4




                                     From a token $n is always the
         $1                           input content (lexem)!
         C1                          From a nonterminal $n is always
                                      the result $$ from this element!

              $1       $2

              C        1
                                     All $n and $$ have the data type
          $$ = "C1";                  String !!!
     Creating an Interpreter from GML
34


        Now we can deal with:
         What will happen when a note rule is applied
         (playing a note or a pause)

        On Worksheet 1 we can find 3 helper functions
         for playing MIDI notes.

        We need to translate key names like C0 into
         according MIDI keys to be played.
     Creating an Interpreter from GML
35
     Creating an Interpreter from GML
36




                               Generate the final
                                interpreter again
     Execute the T-Diagram
37
     Creating a compiler
38



        Create a ML  SVG compiler
         1)   Define a T-Diagram

         2)   Define Scanner and Parser definition

         3)   Create S attributes

         4)   Generate MLSVG compiler

         5)   Test the compiler with the help of the T-Diagram


                                                      Worksheet 2
     Create a T-Diagram
39
     Creating a compiler
40
     Execute the T-Diagram
41


        We can attach our new compiler to the T-
         Diagram and execute it:
       Summary
42

                                         <?xml version="1.0" ?>
                                         <!DOCTYPE svg PUBLIC "-
                        [KeyName, "C"]      //W3C//DTD SVG
     C1-8 E1-4 D0-2 …   [Token1, "1"]       20010904//EN"
                        [Minus, "-"]        "http://www.w3.org/TR/2001/RE
                        …                   C-SVG-...
Thanks for your attention



    Any Questions ?




      www.atocc.de

				
DOCUMENT INFO