Changes between Version 76 and Version 77 of IR2

Timestamp:

05/06/21 10:42:59 (5 years ago)

Author:

siegel

Comment:

--

IR2

@@ -82 +82 @@
 * A typedef can be used to define parameterized types.  The type parameters are listed between angular brackets preceding the typedef.   When the identifier is later used, it must be used with angular brackets and actual type names to replace the type parameters.
 * A declaration declares a variable to have either an object type or a function type.   (An object type is any type that is not a function type.)
-* The optional type-param-list in a declaration may be applied to declaration of function type only.   It declares a "generic" function.  When the function is called (or spawned), the call must include the angular brackets with a list of type names that replace the type parameters used in the declaration or definition of the function.
+* The optional type-param-list in a declaration may be applied only to a declaration of function type.   It declares a "generic" function.  When the function is called (or spawned), the call must include the angular brackets with a list of type names that replace the type parameters used in the declaration or definition of the function.
 * A variable of function type represents either an abstract or a system function.   The declaration of such a variable must use either the qualifier `$abstract_f` or `$system_f`.  Moreover, those two qualifiers can only be used in a declaration of function type.
 * An abstract function represents a new uninterpreted pure function.
@@ -123 +123 @@
   | '$char'  /* character type (Unicode characters, unrelated to integers) */
   | '$real'   /* mathematical reals */
-  | '$float' '<' INT ',' INT '>'  /* IEEE floating-point numbers e=significand bits, f=exponent bits */
+  | '$float32'  /* IEEE 32-bit floating-point numbers */
+  | '$float64'  /* IEEE 64-bit floating-point number */
   | '$herbrand' '<' type-name '>'  /* Herbrand type of non-Herbrand numeric type T */
   | '$proc'  /* process type */
@@ -146 +147 @@
 type-name: ... /* same as declarator but without the ID */
 type-args: '<' type-name (',' type-name)* '>';
-parameter-type-list: type-specifier declarator (type-specifier declarator)* ;
+parameter-type-list: type-specifier declarator (',' type-specifier declarator)* ;
 
 }}}
@@ -163 +164 @@
 
 == Statements ==
+
+An lvalue is an expression that represents an object, as in C.   It is either a variable, an array element expression, a struct or union field expression, or dereference expression.
 
 {{{
@@ -193 +196 @@
 {{{
 expr:
-  | ID
-  | lvalue
+  | ID  /* variable or function identifier */
   | '$true'
   | '$false'
@@ -218 +220 @@
   | '!' expr  /* logical not */
   | expr '<' expr  /* less than */
-  | expr '<=" expr  /* less than or equal to */
+  | expr '<=' expr  /* less than or equal to */
   | expr '[' expr ']'  /* array element access */
   | expr '.' ID  /* field access */
@@ -237 +239 @@
 }}}
 
+* For float types, which rounding mode is used?
+* Comparisons likes `==` and `<` return a `$bool` (not an int, like C)
+
 
 == Standard CIVL Library ==
 
-=== `civlc.cvh` ===
+=== `math.cvh` ===
 
 Work in progress...
+
+Rounding modes:
+* 0 = to nearest
+* 1 = upward
+* 2 = downward
+* 3 = toward zero.
 
 {{{
 $int $round($real x); // round to nearest integer
 $int $floor($real x); // greatest integer less than or equal to
-$int ceil($real x); // least integer greater than or equal to
-$float<e,f> $roundf($real x, $int e, $int f);  // PROBLEM this is not a parameterized type
-
-}}}
-
-
-* `round(e,t)`: returns value in numerical type `t` that is "closest" to the given value `e`
- * add argument for rounding mode?
- * exception if out of range?
-* `floor(e)` : given a real or floating number, returns the greatest `Integer` less than or equal to it.
-* `ceil(e)` : given a real or floating number, returns the least `Integer` greater than or equal to it.
-* `abs(e)`: given any numeric expression e, returns the absolute value; result is same type as `e`.
-* `pow(e,n)`: power operator
- * given any numeric expression e and expression `n` of any integral type, returns e to the n-th power.
- * `n` must evaluate to a nonnegative integer.
-* `herbrand(e)`: "Herbrandize" a numeric value.
- * given a numeric value of type `T`, returns the value as type `Herbrand[T]`, a trivial symbolic expression consisting of a single node.
-* `eval(e)` : evaluate a Herbrand expression
- * given a value of type `Herbrand[T]`, returns the value of type `T` obtained by evaluating all the delayed operations
- * exceptions may be thrown if evaluating any of the delayed operations results in an exception
-
-{{{
-
-}}}
+$int $ceil($real x); // least integer greater than or equal to
+$float32 $round32($real x, $int mode);  // round to float32 (see modes above)
+$float64 $round64($real x, $int mode);  // round to float64 (see modes above)
+<T> T $abs(T x);  // absolute value (T must be a numeric type)
+<T> T $pow(T x, $int n);  // x to the n-th power.  T must be a numeric type; n>=0.
+<T> T $eval($herbrand<T> x);  // returns value of type T obtained by evaluating all the delayed operations
+<T> $herbrand<T> $herbrandize(T x);  // trivial symbolic expression consisting of a single node
+
+}}}
+
+* Is it OK to have parameterized functions that only work for certain T?  Would it better to expand for each numeric type?  E.g., absi, abs, abs32, abs64, ...
 
 === `mem.cvh` ===