FLAME Clarifications

This page contains a list of items that may be confusing or underspecified from the original handout.

Project 3

Numeric literals should be strongly typed. A number "3" is always an integer and is never automatically converted to a float. a number "3.0" is a float.
All expressions and operators are strongly typed. x+y should generate a type error if x and y are not the same type. This also applies to numeric literals. For example, 3 + 4.5 is a type error.

FLAME uses lexical scoping. All variables and parameters must be declared before they are used anywhere within a program. This means that code such as the following is illegal:

fun foo()
    fun bar()
        a:int;
        begin
           a:= 2*z   /* Illegal. z not declared */
        end
    z : int;
    begin
        blah()       /* Illegal. blah not declared */
    end

fun blah()
    begin
    ...
    end

Unindexed array variables may never be used in expressions nor may they be used as lvalues in assignment. FLAME is sort of like C in this regard. For example:

fun foo()  
   a : int[50];
   b : int[50];
   c : int[50];
   i : int;
   begin
      c := a * b;  /* Illegal.  Can't assign to c.
                      Can't have a and b in expression as arrays */

      c[i] := a[i] * b[i];  /* This is okay */
   end

A function may not return an array. For example, in the above example, saying "return a" would be illegal.
Arrays may be passed as function arguments. Therefore, the following statement is legal:
```
    a : int[50];
    b : int[50];

    ...
    foo(a,b);
```
Array sizes are part of the type. So a:int[40] and b:int[50] are different types.
Array dimensions must always be positive and nonzero. There is no empty array specifier to indicate any sized array like in C.
The return type of a function must be inferred from the return statements it uses, and possibly the context in which the function is used in an expression.
If a function returns no value (indicated by control flow that reaches the end of a function with no return statement), the return type of the function should be marked as "none", "empty", "void", or whatever seems most appropriate to you. It is illegal for a void function to be used in an expression:
```
fun foo()
    begin
        skip     /* Do nothing, return nothing */
    end

fun bar()
    x : int;
    begin 
       x := 3+foo(); /* Error: foo returns no value */
    end
```
It is a type error if a function tries to return more than one return type. This includes empty return values (e.g., if some part of a function returns an integer, but another branch returns nothing).
A break statement appearing outside of a while loop is a control flow error (misplaced break).
To simplify your implementation, you may set the type of a boolean expression to an integer. If your parser is implemented correctly, this will work without any trouble.
A function that returns a value can still be used as a statement (i.e., foo(); where foo returns a value is still valid). In this case, the return value (if any) will be discarded.
Array dimensions must be an integer literal or an expression that evaluates to an integer literal.
```
a : int[40];       /* Legal */
b : int[40*50+2];  /* Legal */
c : int[x];        /* Always illegal */
```
Project 2
Relations are not expressions. This means that the following statements are illegal:
```
if 1 then print("Yes!\n")
else print("No.\n")

while x - 100 do
    ...
```
Instead, you need to use one of the relational operators ==, !=, < > <=, or >=. For example:
```
if 1 == 1 then print("Yes!\n")
else print("No.\n")

while x - 100 != 0 do
    ...
```
Compound relations are still relations. For example:
```
while x >= 0 and x < 100 do
    ...
```

Declarations (local variable and nested functions) are always terminated by a semicolon (;). For example:

fun foo(x : int) 
    y : int;
    z : int;
    fun bar(y : int) 
         begin
         ...
         end;   <-- note semicolon here
    a : float;  <-- and here
    begin
         ...
    end

Statements (anything in the begin/end block) are only separated by semicolons. The last statement never has a semicolon. For example:
```
fun foo(x : int) 
    begin
        x := 2*x;
        write(x)    <--  No semicolon here.
    end
```
Function specified at file-scope are not separated by semicolons.
The value passed to the return statement does not always have to be enclosed in parenthesese. For example:
```
return(3*x)
return 0
return 2*4+x
```
Function calls are both expressions and statements. In the case of statements, the return value of a function call is discarded. For example:
```
a := foo(3,4,5);           /* Use as an expression */
foo(6,7,8);                /* Use as a statement */
```
Array indices are expressions in all contexts. For example:
```
a : int[20];           /* Declaration */
b : int[20*20];        /* Declaration */
a[2*i] := 4;            /* Assignment  */
read(b[4*i*j]);        /* Read into a location */
```
Additional checks on the expression are performed later. For instance, we will need to make sure indices are integers at a later stage of the compiler project.