IDLIST → ID ^ ","

1. Give the macrosyntax (for the whole modified language, not just the parts that have changed). Note that the addition of types means you will need literals for each type as well as additional operators to make use of them. Type checking does not need to be done syntactically.
2. Write an abstract syntax for the new language.
3. Write a natural semantics for the new langauge.
4. Write a denotational semantics for the new langauge.

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

1. A number from the set {34,36,37,59,57,365}.
2. The set of all strings over {a,b,c} that do not contain two consecutive a's anywhere in the string.
3. The set of all strings over {a,b} that do not have two consecutive a's nor two consecutive b's anywhere in the string.
4. The set of all strings over {a,b,c} that do not contain three consecutive a's anywhere in the string.
5. The set of all strings over {a,b} that contain neither the substring "aba" nor "babb" anywhere in the string.

    (a = 3) >= m >= ! & 4 * ~ 6 || y %= 7 ^ 6 & p

    if x > 2 or not F(F(X)) then
      Put (-3 * Q);
    elsif not Here or There then
      loop
        while Close loop Try_Harder; end loop;
        X := X ** 3 mod 2*X;
      end loop;
      Q.all(4).G(6) := Person.List(2);
    else
      raise Hell;
    end if;

    int f(int x, int y) {
       return y,x?a.p[5]+=7&!y<x<y+++x||+x|*&y-~--y*x^y:0;
    }

    printf("%08X %#16.7e\n",x---a.p[9]^x|*&p&1,*((float*)&x));

    die "\n">>1,~\$$x^split @a,3|x**$;=>%p&&&p;

    sub f {
        print $x[0] unless q/pig =~ m!^r$!/ =~ m!^\((4)+!x;
        push @_, sort reverse keys %$shift, g A 1, 2
    }

1. Redeclaration of an identifier in Ada.
2. Unbalanced parentheses.
3. Applying an operator to an element of the wrong type in Ada.
4. Array index out of bounds in Ada.
5. Integer division by zero in Ada.
6. Semicolon after a class body in Java.
7. Wrong number of arguments supplied to a call in Java.
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 in Ada.
11. Application of the "." to an identifier which is not a field of the record (or struct) in Ada.
12. Use of an uninitialized variable in Ada.
13. for I in A'Range loop Put("*"); X := X+1; end loop; (Ada).

1. {int x; int x;}
2. {int x; {int x;}}
3. {int x; struct x {};}
4. void f() {return 5;}
5. x +. 2;
6. x = (((int)x)-*0);
7. x---!-+~*&x
8. x = (((int)x)-5));
9. x>&x
10. if (x == 2) {return 1;}; else {return 2;};
11. int a[5]; a[5]=10;
12. float y; double x = y / 0.0;
13. Hawai`i = 2;
14. int y = 0; *y = 7;
15. main(5, 0, 0, 0, 0, 0); /* a call to the usual main() function */
16. printf("%d\n", x, y, z);
17. class C {}
18. struct {int x;} p; p.y;
19. int f() {int* p = p;}
20. int main() {main();}
21. int f() {int p; return p;}

1. let val x = 2 val x = 3 in x end;
2. let val x = 5; val x = "dog" in x end;
3. let val x = print 5 in x end;
4. let val x = print "5" in x end;
5. let val y = ref 2; val x = while (!y < 1) do print "*" in x end;
6. let val y = ref 2; val x = while (!y != 1) do print "*" in x end;
7. let val x = 3 in () end;
8. let val p = *^$q in () end;

1. {w in {a,b,c}* | w has at most one occurence of any symbol}
2. {a^mbⁿc^m+n | m,n >= 1 }

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

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

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

    struct A {B* x; int y;};
    struct B {A* x; int y;};

   local
       fun split [] = ([],[])
         | split [h] = ([h], [])
         | split (x::y::t) = let val (s1,s2) = split t in (x::s1,y::s2) end
       fun merge c ([], x) = x
         | merge c (x, []) = x
         | merge c (h1::t1, h2::t2) =
             if c(h1,h2)<0 then h1::merge c(t1,h2::t2) else h2::merge c(h1::t1,t2);
   in
       fun sort c [] = []
         | sort c x = let val (p, q) = split x
                       in merge c(sort c p, sort c q)
                     end;
   end;

1. During type inference, give the types assigned to
   • the parameter c within sort
   • the function split
   • the function merge
   • the y in the third clause of split?
2. Give the type of sort and explain why it is not what you would expect.
3. How do you rewrite the function to make it actually do a mergesort?

    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. Write a Greatest Common Denominator function in this language.
4. 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.

1. Write an example program in this language that shows off everything described above.
2. Write the microsyntax of this language. Use my EBNF extensions for Unicode categories and subtraction.
3. Write the macrosyntax of this language.
4. Write a program in this language that consists of the declaration of the GCD function followed by a call to this function with the arguments 99 and 66.
5. Show the abstract syntax tree for your GCD program

    DESIGNATOR  →  DESIGNATOR  "."  ID

    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).

• the string may have leading and trailing spaces
• the three fields are separated by a vertical bar
• the weight is not expressed in scientific notation: it can have an integral value, but if it does have a decimal point, then it is followed by a non-empty fractional part. There is no "E" part, ever. It's simple.

    class Item {
        private int id;
        private static int numberOfItemsCreated = 0;
        public Item() {id = numberOfItemsCreated++;}
        // pretend that there are more members here...
    };

1. What construct is used in non-object oriented programming languages to simulate class hierarchies, and why do we say that it is unsafe?
2. Why are inheritance-like structures in non-OOPLs harder to extend?

    class C {protected: int x; ...};
    C c;

then your job is to assign a new value to c.x. Assume there are no public operations of C that modify x that you know of. Also, do not use any preprocessor tricks (like #define protected public).

    class C {int x;};
    C c;
    C* p = &c;
    cout << p;

    ostream& operator<<(ostream&, C*);

For example, if you pass as arguments the function that doubles its inputs, and the list [4, 3, 1, 2, 2], then the return value would be [4, 6, 4, 16, 32].

Hints: Do the f(f(f...)) as a separate function. Also you do NOT have to make your function tail recursive.

Given a list [a₀, a₁, ..., a_n-1] return a₀*a₁ + a₂*a₃ + a₄*a₅ + ....

For example, if given [3, 5, 0, 28, 4, 7] we return 15 + 0 + 28 = 43. If there are an odd number of elements in the list, assume there is an extra "1" for padding.

Because I am in a good mood, here is a NON tail recursive formulation:

    fun sum_of_prods [] = 0
      | sum_of_prods (x::nil) = x
      | sum_of_prods (x::y::t) = x * y + sum_of_prods t;

    [4, 6, 7, 3, 5, 2, 4].weird(addSix, square)

    z(2) == 55

    val dot =
        let
            fun transpose ... =
        in
            ....
        end;

    transpose ([x1,...,xn],[y1,..,yn]) = [(x1,y1),...,(xn,yn)]

    public void fail() {
        class Failure extends RuntimeException {}
        throw new Failure();
    }

    declare x = 2;
    sub f() {print x;}
    sub g() {declare x = 5; f(); print x;}
    g();
    print x;

    x = 1;
    array y = [2, 3, 4];
    sub f(a, b) {b++; a = x + 1;}
    f(y[x], x);
    print x, y;

    class Pair implements Cloneable {
        private Object first, second;

        public Pair(Object x, Object y) {first = x; second = y;}
        public getFirst() {return first;}
        public getSecond() {return second;}
    }

with Ada.Text_IO, Ada.Integer_Text_IO;
use Ada.Text_IO, Ada.Integer_Text_IO;

procedure P is
  A: Integer := 4;
  type T is access Integer;
  B: T := new Integer'(4);
  C: T := new Integer'(4);

  procedure Q (X: in out Integer; Y: T; Z: in out T) is
  begin
    X := 5;
    Y.all := 5;
    Z.all := 5;
  end Q;

begin
  Q (A, B, C);
  Put (A);
  Put (B.all);
  Put (C.all);
end P;

    template <class Item>
    class Container {
    public:
      unsigned numberOfItems() {return currentSize;}
      bool isEmpty() {return currentSize == 0;};
      virtual void flush() = 0;
      ~Container() {flush();}
    private:
      unsigned currentSize;
    };

Here the idea is that each particular (derived) container class shall implement its own flush() operation (which makes sense because different containers are flushed in different ways: there may be arrays, linked lists, rings or hashtables used in the representation), and when a container is destroyed its flush() operation will be automatically invoked. However, the idea is flawed and the code as written causes a terrible thing to happen. What happens?

Blah
dog dog 123
Four

Zero
1234567890*


More stuff!
1234

    if not T'Terminated then
        T.E;
    end if;