Changes between Version 26 and Version 27 of IR

Timestamp:

11/22/15 21:22:29 (10 years ago)

Author:

siegel

Comment:

--

IR

@@ -93 +93 @@
 A type name is a syntactic element that names a type, together with possibly more information that makes the type "complete".  All of the names listed above are type names, such as `int[]`, but so is `int[n*m]`.  This is the same as in C.
 
-The expression `$typeof(T)`, where `T` is a type name, returns a value of type `$type` representing the type `T`.
+The expression `$typefrom(T)`, where `T` is a type name, returns a value of type `$type` representing the type `T`.
+
+The expression `$typeof(e)`, where `e` is an expression, returns the type of `e`, a value of type `$type`.
 
 The expression `$initval(d)` takes a `$type` value `d` and returns the initial value for an object of type `d`.
@@ -110 +112 @@
 // statements (leaving out the chooses and whens for brevity)
 n=10;
-_S=$typeof(struct S { int a[n]; };
+_S=$typefrom(struct S { int a[n]; };
 x1=$initval(_S);
 n=20;
@@ -156 +158 @@
 == Expressions ==
 
-In the following list of expressions, `e`, `e0`, `e1`, etc., are expressions.  `T` is a type name.
+In the following list of expressions, `e`, `e0`, `e1`, etc., are expressions.  `T` is a type name. `t` is an expression of type `$type`.
 
 * literals
@@ -172 +174 @@
  * `NULL` : value of type `void*`
 * variables
-* `$typeof(T)` : an expression of type `$type`
-* `sizeof(T)` : the size of the type named `T`
-* `$initval(e)`, where `e` is an expression of type `$type`
+* `$typefrom(T)` : an expression of type `$type`, the type represented by the type name `T`
+* `$typeof(e)` : expression of type `$type`, the type of the expression `e`
+* `$sizeof(t)` : the size of that type.  Note that the C `sizeof(expr)` can be translated as `$sizeof($typeof(expr))`.  The C `sizeof(T)` can be translated as `$sizeof($typefrom(T))`.
+* `$initval(t)` : initial value of type `t`
 * `$defined(e)`
-* `e1+e2` : addition
+* `e1+e2` : addition.   One of the following must hold:
+ * `e1` and `e2` have the same numeric type.  Note that there are no "automatic conversions" as there are in C.  If the original expressions have different types, explicit casts must be inserted.  
+ * `e1` has pointer type and `e2` has an integer type.  (Alternatively, we could define a separate function `$pointer_add(p,n)`.)
 * `e1-e2` : subtraction
 * `e1*e2` : multiplication
 * `e1/e2` : division
+ * If both are integer types, the result is integer division.  Otherwise it is real division.  Need to define what happens for negative integers.
 * `e1%e2` : modulus
-* `e1[e2]` : array index
+* `e1[e2]` : array subscript expression.  Note that `e1` must have array type, not pointer type. (This is different from C.)   If `e1` has pointer type, use `*(e1+e2)` instead.  
 * `*e` : pointer dereference
 * `&e` : address-of
 * `!e` : logical not
 * `-e` : negative
-* `(T)e` : cast expression
+* `$cast(e,t)` : casts `e` to a value of type `t`
+ * need to list all of the legal casts and what they mean exactly
  * cast of integer to array-of-boolean, and vice-versa?
 * `e1==e2`, `e1!=e2`
@@ -201 +208 @@
 
 
+Pointers: unlike C, there is no "array-pointer pun".   If an array `a` needs to be converted to a pointer, you must use `&a[0]`.
+
 == The Primitive Statements ==
 
@@ -210 +219 @@
 * Wait: `$wait(e);`
 * **Wailtall?**
-* Malloc: `e=(T)$malloc(e1,e2);` **??**
-* Free: `free(e);`
+* Allocation
+ * `e=$allocate(h,t,e);`, where 
+  * `h` as type `$heap`
+  * `t` has type `$type`
+  * `e` has integer type.
+ * Allocates `e` objects of type `t` on heap `h`
+* Free: `free(p);`
 * Noop: `;`
  * **Is there a need to add annotations for "true" or "false" branch, etc.?**
@@ -244 +258 @@
 
 == Libraries ==
-