S → aab | aba | baa | aaSb | abSa | baSa | aSab | aSba | bSaa | SS

1. Prove that aaabbbbaaaaa is not in the language generated by this grammar.
2. Give a correct context free grammar for L (and don't forget, like the freshman did, that the empty string belongs, too).

    IDLIST → ID ^ ","

This form can also be used to model a construct representing "one or more" A's, rather than using AA* or A*A. Show how to do this.

    EXP  → EXP1 ('and' EXP1)*  |  EXP1 ('or' EXP1)*
    EXP1 → EXP2 (RELOP EXP2)?
    EXP2 → '-'? EXP3 (ADDOP EXP3)*
    EXP3 → EXP4 (MULOP EXP4)*
    EXP4 → EXP5 ('**'  EXP5)?  |  'not' EXP5  |  'abs' EXP5

1. Show the abstract syntax tree for the expression -8 * 5
2. Suppose the designers of Ada decided to remove the optional unary negation operator from EXP2 and instead add a clause to the EXP4 rule that said

       '-' EXP5
   

   Draw the abstract syntax tree for -8 * 5 under this supposition.
3. Do you think one reason that the Ada designers crafted their unusual syntax had anything to do with the fact that Ada comments start with "--" and go to the end of the line? In other words, would the rule EXP4 → '-' EXP5 possibly confuse programmers attempting to write double negatives?

1. Redeclaration of an identifier.
2. Unbalanced parentheses.
3. Applying an operator to an element of the wrong type.
4. Array index out of bounds (in C, in Ada, ...).
5. Division by zero.
6. Semicolon after a block in C.
7. Wrong number of arguments supplied to a call.
8. Assignment of a variable of type T to a variable of type subtype of T where the first variable is out of the range of the second in Ada.
9. An unwanted infinite loop.
10. Dereference of a null pointer.
11. Application of the "." to an identifier which is not a field of the record.
12. Use of an uninitialized variable.
13. for x (a) {printf("*"); x = x++;} in Hana.

    for (int i = x-3; q<=4&m.z[r |- 4]&2-8*r>- 5/~x;) {
        while (a) {
            y;
            2,y;
        }
    }

1. What kind of static semantic checks are required for this statement?
2. Give an example piece C code that has a continue statement in it, and show the intermediate and target code for it.

      je    L6
      jmp   L4
L6:

with the single instruction jne L4?

1. {w in {a,b,c}* | w has at most one occurrence of any symbol}
2. {a^mbⁿc^m+n | m,n >= 1 }
3. Palindromes over {a, b}
4. {a^mbⁿ | m >= n }
5. Strings of parentheses, brackets and braces, all properly balanced and nested.
6. Semicolon terminated statements
7. Comma separated expressions
8. Strings over {a, b, c, d, e} containing at most one occurrence of any symbol.

1. {aⁿbⁿcⁿ | n >= 0 }
2. {aⁱb^jc^k | i = j or j = k }
3. {ww | w in {a,b}* }

    type Real_To_Real is access function (Real) return Real;
    type Foo is access procedure (Integer; in out Boolean);
    Sine, Cosine: Real_To_Real;
    P: Foo;
    Q: Real_To_Real;
    function Integrate (F: Real_To_Real; A, B: Real);
    ...
    function Square (X: Real) return Real is
    begin
        return X * X;
    end;
    ...
    Put (Integrate(Square'Access, 3, 10));
    Q := Cosine;
    if Q(Pi)> X then ...

Describe the semantic rules relating to this facility in Ada, and how you would enforce them in a compiler.

1. Show the target code that loads the value of A(J-1) into register eax that would be generated naïvely. Do not forget to show the bounds checking!
2. Show target code to load the value of A(J-1) into register eax in which the "-1" computation is "folded in" to the computation of the base address of A. Note that the bounds checking code will look a little different than in part (a).

    mov    [ebp-8], eax
    mov    eax, [ebp-8]

The second instruction might be able to be removed. But it is easy to see that whether we are able to remove this instruction is undecidable. Why, exactly?

    if (x > 2 || !String.matches(f(x))) {
      write(-3 * q);
    } else if (! here || there) {
      do {
        while (close) tryHarder();
        x = x >>> 3 & 2 * x;
      } while (false);
      q[4].g(6) = person.list[2];
    } else {
      throw up;
    }

    X: Integer := X + 1;
    Foo: Foo;
    Bar: Real := Bar(Foo);

(where global declarations of X, Foo and Bar are visible) are all illegal, since a declaration of an identifier hides global declarations of the same name immediately at the point it appears in the text, but the identifier may not be used until its declaration is complete. Give an alternate interpretation under which these declarations would be legal and explain the advantages and disadvantages of it from both the programmer's and the compiler writer's perspectives.

    int f(int x, char y);
    void g(int x) {if (x < 0) f(2, 'c');}
    int f(int x, char y) {g(randomInteger());}

In C++, when f is finally declared, the names of the formal parameters don't have to be repeated exactly as they appeared in the incomplete specification. But in Ada they do. Explain why the Ada rule makes life much easier for the compiler writer.

    PROGRAM →  (DECL ';')* EXPR
    DECL    →  'val' ID '=' EXPR
            | fun ID '(' PARAMS? ')' '=' EXPR
    EXPR    →  NUMLIT | ID | UOP EXPR | EXPR BOP EXPR
            | EXPR '?' EXPR ':' EXPR |  ID '(' ARGS? ')' | '(' EXPR ')'
    PARAMS  →  ID (',' ID)*
    ARGS    →  EXPR (',' EXPR)*
    UOP     →  '-' | 'abs' | 'not'
    BOP     →  '+' | '-' | '*' | '/' | 'mod' | 'and' | 'or' | '==' | '<'

1. Why is this called a functional language?
2. Is the grammar ambiguous? Why or why not?
3. Give a semantic object hierarchy for this language.
4. Write a Greatest Common Denominator function in this language.
5. Give three examples of syntax errors and three examples of static semantic errors in this language. Make sure to write down all your assumptions; I did not give you any semantics so you will have to make up something reasonable.

    DESIGNATOR  →  DESIGNATOR  "."  ID

for specifying variables made up from a record and a field of the record. But sometimes it can have the additional interpretation that the DESIGNATOR to the left of the dot was the name of a (visible) subprogram and the ID was an object declared immediately inside that subprogram. Show how to rearchitect the semantic object class hierarchy to support this.

    function f, parameters: [x,y], locals: [a]
        function g, parameters: [c], locals: [p,q,r,s]
            function h, parameters: [a], locals: []
        function k, parameters: [], locals: [z]

1. Show what the runtime stack looks like from the call sequence f→g→k→g→h→h→f→k
2. What does the generated assembly language look like when trying to access the value of f.x from h?
3. Which parts of the Carlos compiler need to be rewritten to use this instruction?

    enter n, 0
    enter n, 1
    enter n, 2
    enter n, 3
    ...

and so on. The second column will be the number of clock cycles required on a Pentium for the particular ENTER instruction. The third column will be code equivalent to the ENTER instruction. For example, ENTER n, 1 is equivalent to:

    push ebp
    mov  ebp, esp
    push ebp
    sub  esp, n

The fourth column will be the number of clocks for the code in column 3.

     A -> Ac | d
     B -> (a|b)*A | bba*c

    x / y > (3 * x) || z || x < 3

where the "||" operator is short-circuit, and the variables x, y, and z are all integer variables. Put the value of the expression in eax. Write the best possible code you can for the Pentium 4 processor.

    Weekdays := Day_Set(False, True, True, True, True, True, False);

we could construct the aggregate directly in the variable Weekdays. Give an example of an assignment statement that illustrates the necessity of constructing an aggregate in temporary storage (before copying to the target variable).

    for j := 5 to y do
        y := j * 7 + c;
        printInteger(y - 4);
    end loop;

where y and c are local variables in the current procedure at offsets -12 and +16 respectively. Remember that the range is evaluated only once, the whole loop is skipped on the empty range, etc.). Make sure you respect the overflow semantics! Identify any induction expressions and explain how you optimized them. Compare your hand-written code with that generated by a real compiler.

    int C(int n) {
        int count = 0;
        while (n != 1) {
            n = (n % 2 == 0) ? n / 2 : 3 * n + 1;
        }
        return count;
    }

    y := x * 4 + z;
    z := p * y;
    y := z;
    x := z / y << x;

1. [01]*(10111[01] | 11[01][01][01][01])[01]*
2. ([bc]*a[bc]*a[bc]*)*
3. 0*1 | 0*10
4. c*a[ac]*b[abc]*

    if (x % 4096 == 0) {printf("Don't say \66;\6f;\6f;!");}

Hint: you need strength reduction, too.

    sar eax, 10          to divide by 1024
    sar eax, 8           to divide by 256

This optimization is not safe. Explain why. Show how to make it safe, and explain both why your optimization works and why it is safe.

    EXP     →  EXP  EXP  OP  | INTLIT
    OP      →  +  |  -  |  *  |  /

1. What language is this?
2. Is the grammar ambiguous? Why or why not?
3. Is it LL(k) for any k? If so, for which k? If not, why not?
4. Give a class hierarchy of entities for this language.
5. Give an attribute grammar for this language that can be used to evaluate expressions.

1. x---y
2. x-----y

package p;
class C implements A {
    public static A x = new   t[3];
    Socket s () {
        while (x - 6>p |    e || q +- p) {
            this.x[3] = !v+++t;
        }
    }
    {System.out.println("ooh");}
}

Classify the following as a syntax error, semantic error, or "not a compile time error at all". In the case where code is given, assume all identifiers are properly declared and in scope. All items refer to the Java language.

1. x+++-y
2. x---+y
3. incrementing a read-only variable
4. accessing a private field in another class
5. Using an uninitialized variable
6. Dereferencing a null reference
7. null instanceof C
8. !!x

EBNF generally uses

• A B to mean exactly one A followed by exactly one B
• A? to mean zero or one A
• A* to mean zero or more As
• A | B to mean either exactly one A OR exactly one B

Suppose I wanted to add a new one:

• A₁ # A₂ # ... # A_n to mean "a non-empty string in which each of the A_is appears zero or one times, but in any order."

Show how to write A # B # C using only the conventional EBNF markup.

    double f(double a, double b);

1. Octal constants in C
2. Unsigned binary numbers divisible by 8
3. Hexadecimal numerals divisible by 8 (signed or unsigned!)
4. Floating point constants that are not allowed to have an empty fractional part and can have no more than three digits in the exponent part
5. the set of all character strings that contains neither the substring "exit" nor "exec"

    L1:
        r0 := x
        z := 6
        r1 := 4 - r0
        r2 := 3 >= r1
        if r2 == 0 goto L2
        r3 := y + 4
        r4 := *r3
        z := r4
    L2:

Classify the following as (a) lexical error, (b) syntax error, (c) static semantic error, (d) dynamic semantic error, or (e) no error.

1. A function call with no matching signature in Hana.
2. A function call with no matching signature in C.
3. x < y < z in Hana, where x and y are ints and z is a boolean.
4. x < y < z in C, where x and y and z are all ints.
5. 3[a] in Hana, where a is an array variable.
6. 3[a] in C, where a is an array variable.
7. char x = '\a'; in Hana.
8. char x = '\a'; in C.
9. Value returning function without a return statement, in Hana.
10. Value returning function without a return statement, in C.
11. Semicolon after a block, in Hana.
12. Semicolon after a block, in C.

struct s {boolean x; s y;}
s a(int p, ...) {
    s[] x = new s[]{null, null};
    print($s.p[a] + substring("ff", #s << p|-2));
}

    G -> (S s G)?
    S -> V q e | i f E g | V x
    V -> i | V d i | V a E a
    E -> n | V

1. Write a regex for alphanumeric strings beginning with a letter that are not three characters long ending case-insensitively with "oo".
2. Show how to modify the Hana JavaCC specification to disallow these offensive strings as identifiers, without changing the token specification for ID.
3. Show how to modify the Hana JavaCC specification to disallow these offensive strings as identifiers, by only changing the token specification for ID.

    struct s {int x; int y; string s;}
    s a = new s {
        codepoint(getChar()), codepoint(getChar()), getString()};
    while (a.x++ < a.y) {print($a.s[1]);}

    mov eax, n
    shl eax, 23
    add eax, 3f800000h
    mov [esp-4], eax
    fld dword [esp-4]

    A -> B C
    B -> a | b?c?
    C -> c | BA

(If you are having trouble with this, and you have time, you can write a JavaCC specification and "try it out".) If you find that this grammar is not LL, make one that is (that defines the same language of course).

    IFSTMT -> 'if' '(' EXP ')' BLOCK
              ('else' 'if' '(' EXP ')' BLOCK)*
              ('else' BLOCK)?
    BLOCK -> '{' STMT* '}'

    IFSTMT -> 'if' EXP 'then' STMT+
              ('else' 'if'  EXP 'then' STMT+)*
              ('else' STMT+)?
              'end'