inline funcs instead of macros for fixed-point

src/threads/fixed-point.h

@@ -1,31 +1,95 @@
+#include <stdint.h>
 #ifndef FIXED_POINT_H
 #define FIXED_POINT_H
 
+typedef struct
+{
+  int32_t raw;
+} fp32_t;
+
 /* Fixed Point Arithmetic bit count constants */
-#define NUM_INT_BITS 11
 #define NUM_FRAC_BITS 20
+#define NUM_INT_BITS (31 - NUM_FRAC_BITS)
 #define CONVERSION_CONST (1 << NUM_FRAC_BITS) /* f = 2^q, (2^20) */
 
 /* Fixed Point Arithmetic conversion operations */
 /* Converts an integer n to a fixed point number */
-#define INT_TO_FP(n) ((n) * (CONVERSION_CONST))
+inline fp32_t
+int_to_fp (int32_t n)
+{
+  return { n * CONVERSION_CONST };
+}
 
 /* Handles conversion of fixed point to integer. First version truncates, second one rounds */
-#define FLOOR_FP_TO_INT(x) ((x) / (CONVERSION_CONST))
+inline int32_t
-#define ROUNDING_FP_TO_INT(x) ((x) >= 0 ? ((x) + ((CONVERSION_CONST) / 2)) : ((x) - ((CONVERSION_CONST) / 2)))
+fp_floor (fp32_t x)
+{
+  return { x.raw / CONVERSION_CONST };
+}
 
-/* Fixed Point Arithmetic addition operations */
+inline int32_t
-#define FP_ADD(x, y) ((x) + (y))
+fp_round (fp32_t x)
-#define FP_SUBTRACT(x, y) ((x) - (y))
+{
-/* Addition and Subtraction but between a fixed point and an integer */
+  if (x.raw >= 0)
-#define FP_ADD_INT(x, n) ((x) + ((n) * (CONVERSION_CONST)))
+    return (x.raw + CONVERSION_CONST / 2) / CONVERSION_CONST;
-#define FP_SUBTRACT_INT(x, n) ((x) - ((n) * (CONVERSION_CONST)))
+  else
+    return (x.raw - CONVERSION_CONST / 2) / CONVERSION_CONST;
+}
 
-/* Fixed Point Arithmetic multiplication operations */
+/* Add two fixed points */
-#define FP_MULTIPLY(x, y) ((int64_t)(x)) * (y) / (CONVERSION_CONST)
+inline fp32_t
-#define FP_DIVIDE(x, y) ((int64_t)(x)) * (CONVERSION_CONST) / (y)
+fp_add (fp32_t x, fp32_t y)
-/* Multiplication and division but between a fixed point and an integer */
+{
-#define FP_MULTIPLY_INT(x, n) ((x) * (n))
+  return { x.raw + y.raw };
-#define FP_DIVIDE_INT(x, n) ((x) / (n))
+}
+
+/* Subtract two fixed points */
+inline fp32_t
+fp_sub (fp32_t x, fp32_t y)
+{
+  return { x.raw - y.raw };
+}
+
+/* Add fixed point to integer */
+inline fp32_t
+fp_add_int (fp32_t x, int32_t n)
+{
+  return { x.raw + n * CONVERSION_CONST };
+}
+
+/* Subtract integer from fixed point */
+inline fp32_t
+fp_sub_int (fp32_t x, int32_t n)
+{
+  return { x.raw - n * CONVERSION_CONST };
+}
+
+/* Multiple two fixed points */
+inline fp32_t
+fp_mul (fp32_t x, fp32_t y)
+{
+  return { ((int64_t)x.raw) * y.raw / CONVERSION_CONST };
+}
+
+/* Divide two fixed points */
+inline fp32_t
+fp_div (fp32_t x, fp32_t y)
+{
+  return { ((int64_t)x.raw) * CONVERSION_CONST / y.raw };
+}
+
+/* Multiply fixed point and integer */
+inline fp32_t
+fp_mul_int (fp32_t x, int32_t n)
+{
+  return { x.raw * n };
+}
+
+/* Divide fixed point by integer */
+inline fp32_t
+fp_div_int (fp32_t x, int32_t n)
+{
+  return { x.raw / n };
+}
 
 #endif //FIXED_POINT_H