Sie befinden sich hier: Termine » Prüfungsfragen und Altklausuren » Hauptstudiumsprüfungen » Lehrstuhl 2 » Allgemeines   (Übersicht)

Allgemeines

B: Beisitzer (Kamp)

P: Prüfer (Philippsen)

S: Student

Zeit: 30min (voll ausgenutzt)

Stimmung

Trotz früher Prüfung und Nervosität angenehme und freundliche Atmosphäre. Der Beisitzer stellt wie immer die Fragen und der Prüfer stellt nur ab und zu Detailfragen oder hakt nach. Man sollte die Vorlesungsfolien verstanden haben und besonders die rot markierten Dinge gut können, da großer Wert auf diese gelegt wird.

Java-Code

  class A {
      int x;
      
      /* zeug */
      
      class B {
          int y;
          
          /* zeug */
          
          public int foo(int y) {
              this.y = y;
          }
      }
      
      class C extends B {
          C(int a) {
              super(a);
          }
          
          public int foo(int y) {
              /* zeug */
          }
      }
      
      public int bar(B b) {
          return b.foo(x);
      }
  }

Lexer

B: Wir haben da so Code: this.y = y; Was macht der Compiler damit?

S: Einlesen [und fängt an zu schreiben]

B: Was macht der z.B. mit this?

P: Da steht schon ein TKTHIS.

B: Ahh, dann weiter.

S: TKDOT

B: Bekommt das y auch einen Token?

S: Nein, sondern id und Eintrag in Namenstabelle

Parser

B: Was bekommt der Parser?

S: Die Token und die Namenstabelle

P: Sonst nichts?

S: Und die Grammatikregeln

B: Was macht der Parser damit?

S: Er wendet die Grammatikregeln auf die Token an und prüft so, ob der Code syntaktisch korrekt ist.

Analyse

B: Und was ist mit den Variablen?

S: Es wird geprüft, ob ids bei Benutzung bereits deklariert wurden.

P: Und?

[B zeigt auf public int, meinte aber nur das public]

S: Und, ob ids sichtbar sind.

P: Was passiert noch bei der semantischen Analyse?

S: Typprüfung und programmiersprachliche Regeln

Abbildungsphase

B: Was macht man da?

S: Transformationen

B: Wieso hier?

S: Geht einfach, da man Knoten im AST einfach austauschen kann.

B: Genau. Was macht der Compiler z.B. mit der Klasse B?

S: Nach außen ziehen und umbenennen, damit es keine Komplikationen mit anderen Klassen gibt. [schreibt: class A$B]

B: Wieso schreiben Sie da ein $ hin?

S: Ist in der Sprachdefinition nicht erlaubt und praktisch zum trennen.

B: Ok und weiter?

S: Dann brauchen wir noch eine Referenz auf die äußere Klasse. [schreibt A this$0; auf]

B: Wieso?

S: Damit man danach noch auf das Attribut x zugreifen kann. [will Konstruktor aufschreiben]

B: Ja, das reicht schon. Braucht man die Referenz auf die äußere Klasse immer?

S: [überlegend] Bei statischen Klassen vermutlich nicht.

[P und B schauen gespannt und warten wohl auf eine eindeutige Ja/Nein-Antwort]

S: [zögernd] Nein?

B: Es gibt da noch eine Klasse [zeigt auf C].

S: Auch nach außen ziehen und entsprechend die Variablenzugriffe anpassen.

B: Wie gehts nach den Transformationen weiter?

S: Dann können wir Optimierungen machen.

B: Das lassen wir weg.

P: Das kommt ja dann nächstes Semester.

DP

B zeigt folgenden Baum mit Befehlen und einem Register:

            +
      *           /
  a       b   c       d
  
  R <- M
  M <- R
  R <- R op M
  R <- R op R

P: Bringt der letzte Befehl bei einem Register überhaupt was?

S: Ja natürlich, wenn zwei Teilbäume gleich sind, kann man das Register für beide Operanden benutzen

B: Wie wird denn hier Code mit DP erzeugt?

S: [erklärt ersten Schritt]

B: Und dann sind wir fertig?

S: Nein, natürlich noch nicht. Im zweiten Schritt werden die Teilbäume identifiziert, die in den Speicher geladen werden müssen.

B: Machen Sie mal.

S: [erklärt und markiert + und / Knoten]

P: In welcher Reihenfolge werden die Knoten markiert?

S: Zuerst / dann +

B: Und was dann?

S: Dann wird im dritten Schritt für jeden Teilbaum aus dem zweiten Schritt Code erzeugt, indem …

P: Halt. Für „jeden“? Also parallel oder wie?

S: Nein, die stehen ja in einer Liste und werden nacheinander abgearbeitet.

B: Dann machen Sie doch mal für /

S: [erklärt dritten Schritt]

B: Danke, das reicht.

Methodenauswahl

B: [zeigt auf b.foo(x)] Was kann hier passieren?

S: b kann vom Typ C sein.

B: Was kann das für Probleme verursachen?

S: Welche Methode foo aufgerufen wird.

B: Wie macht man das dann?

[Hier hatte ich eher weniger Ahnung und hab hauptsächlich rumgeeiert]

P: Wie sieht es eigentlich mit der Zeit aus?

B: Ich glaube ziemlich Null.

P: [schaut aufs Handy] Ahh ja. Gehen Sie mal bitte kurz raus.

Besprechung

Nach kurzer Zeit werde ich wieder rein geholt.

P: Was würden Sie sich geben?

S: Keine Ahnung, ich kann sowas nicht einschätzen.

P: Hat auch keinen Einfluss mehr auf die Note.