Changes between Version 111 and Version 112 of IR

Timestamp:

12/02/15 09:33:37 (10 years ago)

Author:

siegel

Comment:

--

IR

@@ -30 +30 @@
 block: '{' typedef* vardecl* fundef* statement* '}' ;
 statement: block | basicStmt ;
-basicStmt:  (ID ':')? (simpleStmt | chooseStmt) ;
-simpleStmt: (guardedStmt | primitiveStmt) ('goto' ID)? ;
+basicStmt:  (ID ':')? (simpleStmt | chooseStmt | gotoStmt) ;
+gotoStmt: 'goto' ID ;
+simpleStmt: (guardedStmt | primitiveStmt) gotoStmt? ;
 guardedStmt: 'when' expr 'do' primitiveStmt ;
 chooseStmt: 'begin choose' simpleStmt+ 'end choose' ;
@@ -143 +144 @@
 A **type name** is a syntactic element that names a (static or value) type.  Examples of type names include `Array[Integer]` and `Array[Integer,24]`.
 
-The expression `new(t)` takes a Dytype and returns the initial value for an object of that type.   The initial value of `Integer` and other primitive (non-compound) types is "undefined".   The initial value of `Array[Integer]` is an array of length 0 of `Integer`.  The initial value of `Pointer[Real]` is the undefined pointer to `Real`.    The initial value of `Array[Real, 10]` is the array of length 10 in which each element is undefined.  In general, the initial value of an array of length n is the sequence of length n in which every element is the initial value of the element type of the array.   The initial value of a tuple type is the tuple in which each component is assigned the initial value for its type.
+The expression `new(t)` takes a Dytype and returns an unconstrained value of that type.
 
 Example:  the C code
@@ -226 +227 @@
  * If `e3` is positive, the integers `e1`, `e1`+`e3`, `e1`+2*`e3`, ... that are less than or equal to `e2`.  If `e3` is negative, the integers `e1`, `e1`+`e3`, `e1`+2*`e3`, ... that are greater than or equal to `e2`.  Exception if `e3` is 0.
 * `domain(<r1,...,rn>)` : value of type `Domain[n]`, the Cartesian product of the n ranges, with dictionary order
-* `hasnext(dom, <i,j,…>)`: an expression of type `Bool`, testing if the domain `dom` contains any element after `<i,j,...>`. If `i` or `j` or ... is undefined, then it evaluates to `false` if `dom` is empty, and `true` if `dom` is not empty.
 
 Arrays (which are also Sequences)
@@ -280 +280 @@
 
 Types
-* `new(t)` : new (default) value of `Dytype` t.  If `t` has type `Dytype[T]`, then this expression has static type `T`.
+* `new(t)` : new unconstrained value of `Dytype` t.  If `t` has type `Dytype[T]`, then this expression has static type `T`.
 * `typeof(e)` : returns the value of type `Dytype` representing the value type of `e`.
  * If `e` has static type `T` then this expression has static type `Dytype[T]`.
@@ -297 +297 @@
 * `"x"` : x is an identifier, naming either a type, variable, or function
 * `sizeof_expr(e)` : the size of the value of expression `e`; return an `Integer`
-* `defined(e)` : is `e` defined? `Bool` type
 * `ite(e1,e2,e3)`: if-then-else (conditional) expression, like `e1?e2:e3` in C.
  * `e1` must have `Bool` type.  `e2` and `e3` must have the same static types, which is the static type of the result.
@@ -333 +332 @@
 * `PARSPAWN p, d, f;` : spawn a sequence of procs
  * `p` has type `Pointer[Proc]`,  `d` has `Domain` type and `f` has `Function` type.
-* `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,...>`
- * if `i`, or `j`, ... is undefined, then `i`, `j`, ... are updated to be the value of the first tuple in `dom`
- * The CIVL-C code `$for(int i,j,...: dom) S;` is translated into the following:
-{{{
-var i: Integer;
-var j: Integer;
+* `NEXT <i,j,...>, dom, flag;` : move to next element in domain
+ * `i`,`j`,... have integral types
+ * `dom` has type `Domain[n]`, where `n` is the number of variables in the sequence `i`,`j`,...
+ * `flag` has type `Bool`
+ * if `flag` is `false` in the pre-state, this indicates you want the first element of the domain
+ * if `flag` is `true` in pre-state, this indicates you want the next element after current `<i,j,...>`
+ * `flag`=`false` in post-state indicates there is no next element
+ * `flag`=`true` in post-state indicates the next element is in `<i,j,...>`
+
+The CIVL-C code `$for(int i,j: dom) S;` is translated into the following:
+{{{
+{
+  var i:Integer;
+  var j:Integer;
+  var flag:Bool;
+
+  flag=false;
 L0:
-begin choose
-  when(hasnext(dom, <i,j,...>)) NEXT dom, <i,j,...>; goto L1;
-  when(not(hasnext(dom, <i,j,...>))) NOOP; goto L2;
-end choose
+  NEXT <i,j>, dom, flag;
+  when not(flag) do NOOP; goto L1;
+  S;
+  goto L0;
+}
 L1:
-  S...
-   ...goto L0;
-L2:
-  ...
 }}}