Changes between Version 121 and Version 122 of IR

Timestamp:

12/09/15 17:15:23 (10 years ago)

Author:

zmanchun

Comment:

--

IR

@@ -253 +253 @@
 
 Pointers and Memory
-* `NULL` : value of type `Pointer`
+* `null` : value of type `Pointer`
 * `deref(e)` : pointer dereference
 * `addr(e)` : address-of operator
@@ -273 +273 @@
 
 Scopes and Processes
-* `root`, `here` : values of type `Scope`
+* `root`, `here`, `scope_null` : values of type `Scope`
 * `self`, `proc_null` : values of type `Proc`
 * `scopeof(e)`: scope of left-hand-side expression `e`
@@ -417 +417 @@
 * `atomic`: function definition is atomic, and it never blocks
  * **ISN'T THIS TRUE OF EVERY SYSTEM FUNCTION?  IN WHICH CASE, IS THIS ONLY FOR NON-SYSTEM FUNCTIONS?**
+* `package="..."`: the package where a system function is implemented
 * `lib="..."`: function is a system function defined in specified library
 * `guard="...":` the name of the guard function
@@ -522 +523 @@
 The CIVL core libraries include:
 
-* `civlc.cvh`: the basic library of CIVL, usually included in a CIVL-C program, defining types and functions that are frequently used;
-
-* `scope.cvh`: providing utility functions related to dynamic scopes;
-
-* `pointer.cvh`: providing utility functions dealing with pointers;
-
-* `seq.cvh`: providing operations on sequences which is realized using arrays;
-
-* `concurrency.cvh`: providing concurrency utilities such as barrier and collective record;
-
-* `bundle.cvh`: defining bundle types and their operations;
-
-* `comm.cvh`: defining communicators and their operations.
+* `civlc`: the basic library of CIVL, usually included in a CIVL-C program, defining types and functions that are frequently used;
+
+* `scope`: providing utility functions related to dynamic scopes;
+
+* `pointer`: providing utility functions dealing with pointers;
+
+* `seq`: providing operations on sequences which is realized using arrays;
+
+* `concurrency`: providing concurrency utilities such as barrier and collective record;
+
+* `bundle`: defining bundle types and their operations;
+
+* `comm`: defining communicators and their operations.
 
 === the basic library `civlc` ===
@@ -544 +545 @@
   This function takes as input a positive integer `n` and nondeterministicaly returns an integer in the range `[0, n − 1]`.
 
-* is a scope reference defined?
-
-  `_Bool $scope_defined($scope s);`
-
-  It returns true if the dynamic scope specified by `s` is defined, else it returns false.
-
-* is a process reference defined?
-
-  `_Bool $proc_defined($proc p);`
-
-  It returns true if and only if the given object of `$proc` type is defined.
-
-=== Scope utilities `scope.cvh` ===
-The header `scope.cvh` declares one function: `$scope` parent, which has signature
-
-`$scope $scope_parent($scope s);`
-
-This function returns the parent dynamic scope of the dynamic scope referenced by `s`. If `s` is the root dynamic scope, it returns the undefined value of type `$scope`.
+=== Scope utilities `scope` ===
+* parent of a scope 
+
+`fun[lib="scope"] $scope_parent(s: Scope): Scope`
+
+This function returns the parent dynamic scope of the dynamic scope referenced by `s`. If `s` is the root dynamic scope, it returns the `scope_null`.
 
 === Pointer utilities `pointer.cvh` ===
@@ -567 +556 @@
 
 * equality checking:
-  `_Bool $equals(void *x, void *y);` 
+  `fun[lib="pointer"] $equals(x: Pointer, y: Pointer): Bool` 
   this function returns true iff the objects pointed to by the pointers `x` and `y` have the same type and value.
 
 * membership testing:
-  `_Bool $contains(void *ptr1, void *ptr2);`
+  `fun[lib="pointer"] $contains(ptr1: Pointer, ptr2: Pointer): Bool`
   this function returns true iff the object pointed to by `ptr1` contains the object pointed to by `ptr2`. For example, `$contains(&a, &a[1].x)` would return true.
 
-* pointer creation:
- $translate ptr for pointer translation; 
+* pointer translation:
+
+    `fun[lib="pointer"] $translate_ptr(ptr: Pointer, obj: Pointer): Pointer`
+
+   this function returns a pointer which is the result of translating the pointer `ptr` (a pointer into one object) to a pointer into a different object `obj` with similar structure.
+
 * copy through pointers:
+  `fun[lib="pointer"] $copy(ptr: Pointer, value: pointer)`
+
+  copies the value pointed to by `value` to the memory location specified by `ptr`.
+
+* get leaf node pointers:
+  
+  `fun[lib="pointer"] $leaf_node_ptrs(array: Pointer, obj: Pointer)`
+
+  copies the references to the leaf nodes of `obj` to the given `array`. The type of `obj` is `Pointer[T']`, all leaf nodes of `T'` has type `T`, and `array` has type `Pointer[Array[T]]`. For example, `T'` could be `Tuple[<Integer, Array[Integer], Integer>]`
+
+* set leaf nodes:
+  `fun[lib="pointer"] `
+
+
 
 Which libraries require system functions?