Changes between Version 99 and Version 100 of IR

Timestamp:

11/30/15 09:45:16 (10 years ago)

Author:

siegel

Comment:

--

IR

@@ -18 +18 @@
 * angular brackets are used to delimit tuples or sequences
 * square brackets are used to delimit parameters in types
-* unlike C, there is no "array-pointer pun".   If an array `a` needs to be converted to a pointer, you must use addr(asub(a, 0))`.
+* unlike C, there is no "array-pointer pun".   If an array `a` needs to be converted to a pointer, you must use `addr(asub(a, 0))`.
 * there are no automatic conversions.  All conversions must be by explicit casts or other functions.   Operations such as numeric addition (`add`) require that both operands have the exact same type.
 * in general, symbols can be used before they are defined, as long as they are in scope.  For example, a function `f` can call `g`, even if `g` is defined after `f` in the same scope.  There is no need for a "prototype".  Similarly, a type definition can refer to a type defined later, or can refer to itself in its own definition.
@@ -312 +312 @@
 * `SPAWN f, <e1,...,en>;` and `SPAWN e, f, <e1,...,en>;`
 * `WAIT e;`
-* `WAITALL e, n;` where `e` is a pointer to a process reference and `n` is the number of processes to be waited for 
+* `WAITALL e, n;` : wait on all procs in a list
+ * `e` has type `Pointer[Proc]` and `n` has an integral type, the number of procs in the list
 * `ALLOCATE e, h, t, e0;`
  * `e` has static type `Pointer[T]`, for some static type `T`
@@ -318 +319 @@
  * `t` has type `Dytype[T]`, for the same static type `T`
  * `e0` has an integral type.
- * Allocates `e0` objects of type `t` on heap `h`, returning pointer to first element in `e`.  **WOULD IT BE BETTER TO SPECIFY THE SCOPE?**
+ * Allocates `e0` objects of type `t` on heap `h`, returning pointer to first element in `e`.
+ * **WOULD IT BE BETTER TO SPECIFY THE SCOPE?**
  * To translate the C `malloc` you first need to figure out the type of the elements being malloced.  If the argument to malloc is `n`, then you first need to insert an assertion `eq(mod(n, sizeof_type(t)), 0)`, and then `ALLOCATE e, h, t, div(n, sizeof_type(t))`.
 * `FREE p;`
-* `EVAL e;`, where `e` is an expression that might contain exceptions (e.g., array index out of bound, division by zero);
+* `EVAL e;` : evaluates an expression `e`
+ * useful only because `e` might contain exceptions (e.g., array index out of bound, division by zero)
 * `NOOP;`
  * **Is there a need to add annotations for "true" or "false" branch, etc.?**  If so, we can just make these parameters to the Noop.
@@ -328 +331 @@
 * `ATOMIC_EXIT;`
 * `PARSPAWN p, d, f;` where `p` is pointer to process reference, `d` has `Domain` type and `f` has `Function` type.
-* `NEXT dom, <i,j,…>;` : domain iterator: updates `i`,`j`,... to be the value of the next tuple in `dom` after `<i,j,...>`
-* `FOR_ENTER dom;` **FIX ME**
+* `NEXT dom, <i,j,…>;` : move to next element in domain
+ * updates `i`,`j`,... to be the value of the next tuple in `dom` after `<i,j,...>`
+* `FOR_ENTER dom;`
+ * **FIX ME**
 
 ==  Function Definitions ==