All questions refer to the following
class dictionary:

import edu.neu.ccs.demeter.dj.*;

Input = Component Attachment.
Component = 
  "component" <name> ComponentName
  "class" "graph" <classGraph> MyClassGraph
  "provides" <provides> Provided
  "expects" <expects> PList(Normal)
  ["constraints" <constraints> PList(Constraint)]
  "classes" <local> PList(ClassName).
Attachment = 
  "attachment" <superImpose> CList(ComponentName) 
  "on" <target> ComponentName.

ComponentName = Ident.
ClassGraphName = Ident.
ClassName = Ident.

Provided = <fms>  PList(FunctionMember).
MyClassGraph = <classGraphName> ClassGraphName.
FunctionMember : Normal | Aspectual.
Normal = "normal".
Aspectual = "aspectual".
Member = "member".
Constraint = .

PList(S) ~ "{" S {";" S} "}".
CList(S) ~ "(" S {"," S} ")".
Main = .

All questions refer to the following program:

Main {
{{
  static ClassGraph cg;
  public static void main(String args[]) throws Exception {
    cg = new ClassGraph(true, false);
    ClassGraph cgWT = new ClassGraph(Main.cg,
	 "from Input bypassing -> *,tail,* to *");
    cg = cgWT;
    Input c = Input.parse(System.in);
    c.display();
    System.out.println();
    System.out.println("original Input-object");
    c.print();
    System.out.println();
    c.normals();
    c.updateInput();
    c.print();
    System.out.println();
    c.normals();
    System.out.println();
    TraversalGraph tg = new TraversalGraph(
      "from Input via Provided to Normal", cg);
    System.out.println(tg);

    System.out.println(" done ");
  }
}}
}

Input {
  void display() to * (DisplayVisitor);
  void print() to * (PrintVisitor);
}
Normal {
  void print() to * (PrintVisitor);
}

Input {
{{
  void normals(){
    System.out.println(" all Normal objects reachable from Input ");
    Main.cg.traverse(this,"from Input to Normal", 
      new Visitor() {
	public void before (Normal host) {
	  host.print();
          System.out.println();
        }
      });
  }
  void updateInput(){
    System.out.println(" update Provided: add one Normal-object ");
    Main.cg.traverse(this,"from Input to Provided", 
      new Visitor() {
	public void before (Provided host) {
	  host.get_fms().addElement(new Normal());
        }
      });
  }

}}
}

Question 1:
===========
10 points

Consider the following input in program.input:

"It works!"

What output will the parser produce for this input?

UNKNOWN1

Question 2:
===========

Write a method called normals() which prints
for a given Input-object o all Normal-objects
that o contains.

UNKNOWN2

Question 3:
===========

Write a method called updateInput() which updates
a given Input-object o by adding one Normal-object
at the end of the list fms contained in every 
Provided-object of o.

For example, if the Input-object is:

component T
  class graph G
  provides {aspectual}
  expects {normal}
  classes {T1}
attachment (Y) on B

the modified Input-object should be:

component T
  class graph G
  provides {aspectual;normal}
  expects {normal}
  classes {T1}
attachment (Y) on B

UNKNOWN3

Question 4:
===========

When we call the print() method on the following
Input-object, what gets printed?

: Input  (
 <component> : Component  (
  <name> : ComponentName  (
   <ident>  : Ident "A" )
  <classGraph> : MyClassGraph  (
   <classGraphName> : ClassGraphName  (
    <ident>  : Ident "G" ) )
  <provides> : Provided  (
   <fms> : FunctionMember_PList  {
    <first> : Nonempty_FunctionMember_PList  (
     <it> : Normal  ( )
     <next> : Nonempty_FunctionMember_PList  (
      <it> : Aspectual  ( )
      <next> : Nonempty_FunctionMember_PList  (
       <it> : Normal  ( )
       <next> : Nonempty_FunctionMember_PList  (
        <it> : Aspectual  ( ) ) ) ) ) } )
  <expects> : Normal_PList  {
   <first> : Nonempty_Normal_PList  (
    <it> : Normal  ( )
    <next> : Nonempty_Normal_PList  (
     <it> : Normal  ( ) ) ) }
  <constraints> : Constraint_PList  {
   <first> : Nonempty_Constraint_PList  (
    <it> : Constraint  ( ) ) }
  <local> : ClassName_PList  {
   <first> : Nonempty_ClassName_PList  (
    <it> : ClassName  (
     <ident>  : Ident "R" )
    <next> : Nonempty_ClassName_PList  (
     <it> : ClassName  (
      <ident>  : Ident "S" )
     <next> : Nonempty_ClassName_PList  (
      <it> : ClassName  (
       <ident>  : Ident "T" ) ) ) ) } )
 <attachment> : Attachment  (
  <superImpose> : ComponentName_CList  {
   <first> : Nonempty_ComponentName_CList  (
    <it> : ComponentName  (
     <ident>  : Ident "X" )
    <next> : Nonempty_ComponentName_CList  (
     <it> : ComponentName  (
      <ident>  : Ident "Y" )
     <next> : Nonempty_ComponentName_CList  (
      <it> : ComponentName  (
       <ident>  : Ident "Z" ) ) ) ) }
  <target> : ComponentName  (
   <ident>  : Ident "A" ) ) )


UNKNOWN4

original Input-object

component A class graph G provides{normal;aspectual;normal;aspectual}expects{normal;normal}constraints{}classes{R;S;T}attachment(X,Y,Z)on A

Question 5:
===========

Consider the traversal specification:

from Input through Provided to Normal

For which classes would you have to write code if
you would have to implement this traversal manually
following the Law of Demeter?

Give the list of classes:

UNKNOWN 5