Changeset fd54fef for libcfa/src/vec

Timestamp:

Jan 19, 2021, 8:44:29 PM (5 years ago)

Author:

Michael Brooks <mlbrooks@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

dafbde8

Parents:

2f47ea4

Message:

Converting the project to use the new syntax for otype, dtype and ttytpe.

Changed prelude (gen), libcfa and test suite to use it. Added a simple deprecation rule of the old syntax to the parser; we might wish to support both syntaxes "officially," like with an extra CLI switch, but this measure should serve as a simple reminder for our team to try the new syntax.

Location:

libcfa/src/vec

Files:

• vec.hfa (modified) (7 diffs)
• vec2.hfa (modified) (3 diffs)
• vec3.hfa (modified) (3 diffs)
• vec4.hfa (modified) (3 diffs)

libcfa/src/vec/vec.hfa

@@ -18 +18 @@
 #include <math.hfa>
 
-trait fromint(otype T) {
+trait fromint(T) {
     void ?{}(T&, int);
 };
-trait zeroinit(otype T) {
+trait zeroinit(T) {
     void ?{}(T&, zero_t);
 };
-trait zero_assign(otype T) {
+trait zero_assign(T) {
     T ?=?(T&, zero_t);
 };
-trait subtract(otype T) {
+trait subtract(T) {
     T ?-?(T, T);
 };
-trait negate(otype T) {
+trait negate(T) {
     T -?(T);
 };
-trait add(otype T) {
+trait add(T) {
     T ?+?(T, T);
 };
-trait multiply(otype T) {
+trait multiply(T) {
     T ?*?(T, T);
 };
-trait divide(otype T) {
+trait divide(T) {
     T ?/?(T, T);
 };
-trait lessthan(otype T) {
+trait lessthan(T) {
     int ?<?(T, T);
 };
-trait equality(otype T) {
+trait equality(T) {
     int ?==?(T, T);
 };
-trait sqrt(otype T) {
+trait sqrt(T) {
     T sqrt(T);
 };
@@ -68 +68 @@
 }
 
-trait dottable(otype V, otype T) {
+trait dottable(V, T) {
     T dot(V, V);
 };
@@ -74 +74 @@
 static inline {
 
-forall(otype T | sqrt(T), otype V | dottable(V, T))
+forall(T | sqrt(T), V | dottable(V, T))
 T length(V v) {
    return sqrt(dot(v, v));
 }
 
-forall(otype T, otype V | dottable(V, T))
+forall(T, V | dottable(V, T))
 T length_squared(V v) {
    return dot(v, v);
 }
 
-forall(otype T, otype V | { T length(V); } | subtract(V))
+forall(T, V | { T length(V); } | subtract(V))
 T distance(V v1, V v2) {
     return length(v1 - v2);
 }
 
-forall(otype T, otype V | { T length(V); V ?/?(V, T); })
+forall(T, V | { T length(V); V ?/?(V, T); })
 V normalize(V v) {
     return v / length(v);
@@ -95 +95 @@
 
 // Project vector u onto vector v
-forall(otype T, otype V | dottable(V, T) | { V normalize(V); V ?*?(V, T); })
+forall(T, V | dottable(V, T) | { V normalize(V); V ?*?(V, T); })
 V project(V u, V v) {
     V v_norm = normalize(v);
@@ -102 +102 @@
 
 // Reflect incident vector v with respect to surface with normal n
-forall(otype T | fromint(T), otype V | { V project(V, V); V ?*?(T, V); V ?-?(V,V); })
+forall(T | fromint(T), V | { V project(V, V); V ?*?(T, V); V ?-?(V,V); })
 V reflect(V v, V n) {
     return v - (T){2} * project(v, n);
@@ -111 +111 @@
 // entering material (i.e., from air to water, eta = 1/1.33)
 // v and n must already be normalized
-forall(otype T | fromint(T) | subtract(T) | multiply(T) | add(T) | lessthan(T) | sqrt(T),
-       otype V | dottable(V, T) | { V ?*?(T, V); V ?-?(V,V); void ?{}(V&, zero_t); })
+forall(T | fromint(T) | subtract(T) | multiply(T) | add(T) | lessthan(T) | sqrt(T),
+       V | dottable(V, T) | { V ?*?(T, V); V ?-?(V,V); void ?{}(V&, zero_t); })
 V refract(V v, V n, T eta) {
     T dotValue = dot(n, v);
@@ -128 +128 @@
 // i is the incident vector
 // ng is the geometric normal of the surface
-forall(otype T | lessthan(T) | zeroinit(T), otype V | dottable(V, T) | negate(V))
+forall(T | lessthan(T) | zeroinit(T), V | dottable(V, T) | negate(V))
 V faceforward(V n, V i, V ng) {
     return dot(ng, i) < (T){0} ? n : -n;

libcfa/src/vec/vec2.hfa

@@ -19 +19 @@
 #include "vec.hfa"
 
-forall (otype T) {
+forall (T) {
     struct vec2 {
         T x, y;
@@ -25 +25 @@
 }
 
-forall (otype T) {
+forall (T) {
     static inline {
 
@@ -279 +279 @@
 }
 
-forall(dtype ostype, otype T | writeable(T, ostype)) {
+forall(ostype &, T | writeable(T, ostype)) {
     ostype & ?|?(ostype & os, vec2(T) v) with (v) {
         return os | '<' | x | ',' | y | '>';

libcfa/src/vec/vec3.hfa

@@ -19 +19 @@
 #include "vec.hfa"
 
-forall (otype T) {
+forall (T) {
     struct vec3 {
         T x, y, z;
@@ -25 +25 @@
 }
 
-forall (otype T) {
+forall (T) {
     static inline {
 
@@ -288 +288 @@
 }
 
-forall(dtype ostype, otype T | writeable(T, ostype)) {
+forall(ostype &, T | writeable(T, ostype)) {
     ostype & ?|?(ostype & os, vec3(T) v) with (v) {
         return os | '<' | x | ',' | y | ',' | z | '>';

libcfa/src/vec/vec4.hfa

@@ -19 +19 @@
 #include "vec.hfa"
 
-forall (otype T) {
+forall (T) {
     struct vec4 {
         T x, y, z, w;
@@ -25 +25 @@
 }
 
-forall (otype T) {
+forall (T) {
     static inline {
 
@@ -283 +283 @@
 }
 
-forall(dtype ostype, otype T | writeable(T, ostype)) {
+forall(ostype &, T | writeable(T, ostype)) {
     ostype & ?|?(ostype & os, vec4(T) v) with (v) {
         return os | '<' | x | ',' | y | ',' | z | ',' | w | '>';