How the Fourth Dimension Works with Arrays

To elaborate DeadMG's answer, it sounds like they mean:

1. Static array: an array whose size is known, and whose storage is allocated, at compile time. In C, you might write at global (file) scope:

   int static_array[7];
   

2. Fixed stack-dynamic array: you know the size of your array at compile time, but allow it to be allocated automatically on the stack (the size is fixed at compile time but the storage is allocated when you enter its scope, and released when you leave it)

   void foo()
   {
     int fixed_stack_dynamic_array[7];
     /* ... */
   }
   

3. Stack dynamic array: you don't know the size until runtime, eg. C99 allows this:

   void foo(int n)
   {
     int stack_dynamic_array[n];
     /* ... */
   }
   

4. Fixed heap dynamic array: same as the 2 except using explicit heap allocation

   int * fixed_heap_dynamic_array = malloc(7 * sizeof(int));
   

5. Heap dynamic array: you can probably guess this:

   void foo(int n)
   {
     int * heap_dynamic_array = malloc(n * sizeof(int));
   }
   

Is this the same book as Concepts of Programming Languages? Because again, these aren't a useful classification of types, they only address the allocation mechanism. Once you pass any of these "different" things into a function, their classification under this scheme is irrelevant.

You will probably make it a lot easier on yourself and avoid a lot of user errors if you allow the declaration of variable-length arrays to be delayed until a point where the size is known. Then you don't have to invent a syntax for assigning the array size and you don't have to deal with differences in the order in which arrays are declared and in which they get their size.

If your compiler uses a stack-based allocation scheme for local variables (they are given addresses relative to the stack-frame of their function, like it is done for the 'big' platforms), the variable-length arrays can just be carved out of the stack frame as needed. Only if there are multiple variable-length arrays in a function do you need an additional pointer to indicate where the data of each starts.

If your compiler uses a fixed allocation scheme (all variables, including locals, are given a fixed (absolute) address by the compiler/linker), I would use an 'array stack' for carving the variable-length arrays from. As overhead, you would need a global pointer to indicate where the free space currently starts, a pointer for each variable-length array to indicate where its data is located and, in each function using variable-length arrays, a way to restore the global pointer to the value it had when entering the function.
The user would also need some way to indicate to the compiler/linker how much of a 'array stack' he thinks will be needed. A reasonable default could be to use whatever is left after allocating all fixed-size variables and variable-length array overhead.

I think this scheme uses the least amount of overhead, both space and time-wise. The scheme you came up with is essentially a malloc implementation.