Here I submit to you a patch that adds the following builtin functions to make: `add` (addition), `sub` (subtraction), `mul` (multiplication), `div` (division), `mod` (modulus), `max` (maximum), `min` (minimum), and `abs` (absolute value). The implementation I provide supports both integers and floats with promotions from integer to float when appropriate (an operation where at least one argument is a float causes the other argument to be promoted to a float and the result to be a float).
I attempted to keep the operations behavior similar to how they behave in Scheme. Here are the function details: Calling `add` with a single argument simply returns that argument; `add` accepts 1+ arguments. Calling `sub` with a single argument returns the negation of that argument; `sub` accepts 1+ arguments. Calling `mul` with a single argument simply returns that argument; `mul` accepts 1+ arguments. Calling `div` with a single argument returns the inverse of that argument (i.e., `1/arg`); `div` accepts 1+ arguments. Furthermore, all divisors are checked against being zero. Calling `mod` requires that exactly two arguments are provided and that both arguments are integers. Furthermore, the divisor is checked against being zero. Calling `max` with a single argument simply returns that argument; `max` accepts 1+ arguments. Calling `min` with a single argument simply returns that argument; `max` accepts 1+ arguments. Calling `abs` requires exactly one argument. Please let me know what you all think. >From 76db129404896c15440b405949b8c830e7ebb98f Mon Sep 17 00:00:00 2001 From: Pete Dietl <petedi...@gmail.com> Date: Fri, 29 Nov 2024 03:57:06 -0800 Subject: [PATCH] Add arithmetic builtin functions --- src/function.c | 401 ++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 400 insertions(+), 1 deletion(-) diff --git a/src/function.c b/src/function.c index b4c38052..61cb7d5b 100644 --- a/src/function.c +++ b/src/function.c @@ -14,6 +14,10 @@ A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>. */ +#include <assert.h> +#include <math.h> +#include <stdlib.h> + #include "makeint.h" #include "filedef.h" #include "variable.h" @@ -23,7 +27,6 @@ this program. If not, see <https://www.gnu.org/licenses/>. */ #include "commands.h" #include "debug.h" - struct function_table_entry { union { @@ -952,6 +955,394 @@ func_let (char *o, char **argv, const char *funcname UNUSED) return o + strlen (o); } +enum number_type +{ + t_integer, + t_floating +}; + +struct number +{ + enum number_type type; + union + { + double floating; + long long integer; + }; +}; + +enum math_operation_init_type +{ + t_constant, + t_first_value, +}; + +struct math_operation_init +{ + enum math_operation_init_type init_type; + long long constant; +}; + +enum math_operation +{ + op_add, + op_subtract, + op_multiply, + op_max, + op_min, + op_abs, +}; + +/* Generic function for double */ +static inline double +generic_math_op_double (double a, double b, enum math_operation op) +{ + switch (op) + { + case op_add: + return a + b; + case op_subtract: + return a - b; + case op_multiply: + return a * b; + case op_max: + return (a > b) ? a : b; + case op_min: + return (a < b) ? a : b; + case op_abs: + return fabs (a); + default: + /* Handle invalid operation */ + return 0.0; + } +} + +/* Generic function for long long int */ +static inline long long int +generic_math_op_ll (long long int a, long long int b, enum math_operation op) +{ + switch (op) + { + case op_add: + return a + b; + case op_subtract: + return a - b; + case op_multiply: + return a * b; + case op_max: + return (a > b) ? a : b; + case op_min: + return (a < b) ? a : b; + case op_abs: + return llabs (a); + default: + /* Handle invalid operation */ + return 0; + } +} + +/* Generic macro to select the correct function based on type and + assert that the types of a and b are the same */ +#define generic_math_op(a, b, op) \ + ((void)sizeof ( \ + char[__builtin_types_compatible_p (typeof (a), typeof (b)) ? 1 : -1]), \ + _Generic ((a), \ + double: generic_math_op_double, \ + long long int: generic_math_op_ll) (a, b, op)) + +static struct number +parse_number (const char *s, const char *op_name) +{ + const char *beg = s; + const char *end = s + strlen (s) - 1; + char *endp; + struct number ret = { .integer = 0, .type = t_integer }; + + while (isspace(*s)) + s++; + + // We need to check this because even though we can command `strtoll` to + // parse only base-ten numbers, we can't command `strtod` to only parse + // base-10 numbers. Therefore, without this check `0xB` would get rejected by + // `strtoll`, but accepted by `strtod` and treated as `11.0`. + if (*s != '\0' && s[1] == 'x') + OSS (fatal, *expanding_var, + _ ("Invalid argument to %s function: '%s' not a number"), op_name, s); + + errno = 0; + ret.integer = strtoll (beg, &endp, 10); + if (errno == ERANGE) + OSS (fatal, *expanding_var, + _ ("Invalid argument to %s function: '%s' out of range"), op_name, s); + if (endp == beg || endp <= end) + { + /* Empty or not an integer */ + errno = 0; + ret.type = t_floating; + ret.floating = strtod (beg, &endp); + if (errno == ERANGE) + OSS (fatal, *expanding_var, + _ ("Invalid argument to %s function: '%s' out of range"), op_name, + s); + if (endp == beg || endp <= end) + OSS (fatal, *expanding_var, + _ ("Invalid argument to %s function: '%s'"), op_name, s); + } + + return ret; +} + +static char * +number_to_string (char *o, struct number n) +{ + char buffer[64]; + if (n.type == t_integer) + snprintf (buffer, sizeof buffer, "%lld", n.integer); + else + { + char *end; + snprintf (buffer, sizeof buffer, "%.14f", n.floating); + end = buffer + strlen (buffer) - 1; + while (end > buffer && *end == '0') + *end-- = '\0'; // Remove trailing zero + + // If there's a decimal point left, append a '0' to keep a single zero + if (*end == '.') + { + end++; + *end++ = '0'; + *end = '\0'; + } + } + return variable_buffer_output (o, buffer, strlen (buffer)); +} + +struct number +perform_math_op (enum math_operation op, const char *op_name, + struct math_operation_init init, char **argv) +{ + struct number parsed; + struct number total; + + if (init.init_type == t_first_value) + { + assert (*argv != NULL); + + total = parse_number (*argv, op_name); + argv++; + } + else + { + total.type = t_integer; + total.integer = init.constant; + } + + for (; *argv != NULL; argv++) + { + parsed = parse_number (*argv, op_name); + if (total.type == t_integer) + { + if (parsed.type == t_integer) + total.integer + = generic_math_op (total.integer, parsed.integer, op); + else // `parsed` is floating, `total`` is integer. So, convert total + // to floating + { + total.type = t_floating; + total.floating = generic_math_op ((double)total.integer, + parsed.floating, op); + } + } + else // `total` is floating + { + if (parsed.type == t_integer) + total.floating + = generic_math_op (total.floating, (double)parsed.integer, op); + else // `parsed` is floating, `total`` is floating + total.floating + = generic_math_op (total.floating, parsed.floating, op); + } + } + + return total; +} + +static char * +func_add (char *o, char **argv, const char *funcname) +{ + struct number n = perform_math_op ( + op_add, funcname, + (struct math_operation_init){ .init_type = t_constant, .constant = 0 }, + argv); + + return number_to_string (o, n); +} + +static char * +func_subtract (char *o, char **argv, const char *funcname) +{ + struct math_operation_init init; + struct number n; + + // If we received a single argument, negate it. + if (argv[0] != NULL && argv[1] == NULL) + { + init.init_type = t_constant; + init.constant = 0; + } + else + init.init_type = t_first_value; + + n = perform_math_op (op_subtract, funcname, init, argv); + + return number_to_string (o, n); +} + +static char * +func_multiply (char *o, char **argv, const char *funcname) +{ + struct number n = perform_math_op ( + op_multiply, funcname, + (struct math_operation_init){ .init_type = t_constant, .constant = 1 }, + argv); + + return number_to_string (o, n); +} + +static char * +func_divide (char *o, char **argv, const char *funcname) +{ + struct number parsed; + struct number total; + + // We either received one argument and we will return its inverse or we will use it as + // our initial value for `total` and carry on dividing. + total = parse_number (*argv, funcname); + + if (total.type == t_integer ? total.integer == 0 : total.floating == 0.0) + OS (fatal, *expanding_var, + _ ("Invalid argument to %s function: argument cannot be zero"), funcname); + + // If we received a single argument, compute its inverse. + if (argv[0] != NULL && argv[1] == NULL) + { + if (total.type == t_integer) + total.integer = 1 / total.integer; + else + total.floating = 1.0 / total.floating; + + return number_to_string (o, total); + } + + // We are using argv[0] as our initial value for total, so skip past it. + argv++; + + for (; *argv != NULL; argv++) + { + parsed = parse_number (*argv, funcname); + + if (parsed.type == t_integer ? parsed.integer == 0 : parsed.floating == 0.0) + OS (fatal, *expanding_var, + _ ("Invalid argument to %s function: argument cannot be zero"), funcname); + if (total.type == t_integer) + { + if (parsed.type == t_integer) + total.integer /= parsed.integer; + else // `parsed` is floating, `total`` is integer. So, convert total + // to floating + { + total.type = t_floating; + total.floating = (double)total.integer / parsed.floating; + } + } + else // `total` is floating + { + if (parsed.type == t_integer) + total.floating /= (double)parsed.integer; + else // `parsed` is floating, `total`` is floating + total.floating /= parsed.floating; + } + } + + return number_to_string (o, total); +} + +static char * +func_modulus (char *o, char **argv, const char *funcname) +{ + struct number parsed; + struct number total; + + // We require exactly two arguments + assert(argv[0] != NULL && argv[1] != NULL && argv[2] == NULL); + + // We either received one argument and we will return its inverse or we will use it as + // our initial value for `total` and carry on dividing. + total = parse_number (argv[0], funcname); + + if (total.type == t_floating) + OS (fatal, *expanding_var, + _ ("Invalid argument to %s function: argument must be an integer"), funcname); + + if (total.integer == 0) + OS (fatal, *expanding_var, + _ ("Invalid argument to %s function: argument cannot be zero"), funcname); + + parsed = parse_number (argv[1], funcname); + + if (parsed.type == t_floating) + OS (fatal, *expanding_var, + _ ("Invalid argument to %s function: argument must be an integer"), funcname); + + if (parsed.integer == 0) + OS (fatal, *expanding_var, + _ ("Invalid argument to %s function: argument cannot be zero"), funcname); + + total.integer %= parsed.integer; + + return number_to_string (o, total); +} + +static char * +func_maximum (char *o, char **argv, const char *funcname) +{ + struct number n = perform_math_op ( + op_max, funcname, + (struct math_operation_init){ .init_type = t_first_value}, + argv); + + return number_to_string (o, n); +} + +static char * +func_minimum (char *o, char **argv, const char *funcname) +{ + struct number n = perform_math_op ( + op_min, funcname, + (struct math_operation_init){ .init_type = t_first_value}, + argv); + + return number_to_string (o, n); +} + +static char * +func_absolute_value (char *o, char **argv, const char *funcname) +{ + struct number n; + + // We accept exactly one argumnent + assert(argv[0] != NULL && argv[1] == NULL); + + n = parse_number (argv[0], funcname); + + if (n.type == t_integer) + n.integer = llabs(n.integer); + else + n.floating = fabs(n.floating); + + return number_to_string (o, n); +} + struct a_word { struct a_word *chain; @@ -2394,6 +2785,8 @@ static char *func_call (char *o, char **argv, const char *funcname); static const struct function_table_entry function_table_init[] = { /* Name MIN MAX EXP? Function */ + FT_ENTRY ("abs", 1, 1, 1, func_absolute_value), + FT_ENTRY ("add", 1, 0, 1, func_add), FT_ENTRY ("abspath", 0, 1, 1, func_abspath), FT_ENTRY ("addprefix", 2, 2, 1, func_addsuffix_addprefix), FT_ENTRY ("addsuffix", 2, 2, 1, func_addsuffix_addprefix), @@ -2401,6 +2794,7 @@ static const struct function_table_entry function_table_init[] = FT_ENTRY ("basename", 0, 1, 1, func_basename_dir), FT_ENTRY ("call", 1, 0, 1, func_call), FT_ENTRY ("dir", 0, 1, 1, func_basename_dir), + FT_ENTRY ("div", 1, 0, 1, func_divide), FT_ENTRY ("error", 0, 1, 1, func_error), FT_ENTRY ("eval", 0, 1, 1, func_eval), FT_ENTRY ("file", 1, 2, 1, func_file), @@ -2416,6 +2810,10 @@ static const struct function_table_entry function_table_init[] = FT_ENTRY ("join", 2, 2, 1, func_join), FT_ENTRY ("lastword", 0, 1, 1, func_lastword), FT_ENTRY ("let", 3, 3, 0, func_let), + FT_ENTRY ("max", 1, 0, 1, func_maximum), + FT_ENTRY ("min", 1, 0, 1, func_minimum), + FT_ENTRY ("mod", 2, 2, 1, func_modulus), + FT_ENTRY ("mul", 1, 0, 1, func_multiply), FT_ENTRY ("notdir", 0, 1, 1, func_notdir_suffix), FT_ENTRY ("or", 1, 0, 0, func_or), FT_ENTRY ("origin", 0, 1, 1, func_origin), @@ -2424,6 +2822,7 @@ static const struct function_table_entry function_table_init[] = FT_ENTRY ("shell", 0, 1, 1, func_shell), FT_ENTRY ("sort", 0, 1, 1, func_sort), FT_ENTRY ("strip", 0, 1, 1, func_strip), + FT_ENTRY ("sub", 1, 0, 1, func_subtract), FT_ENTRY ("subst", 3, 3, 1, func_subst), FT_ENTRY ("suffix", 0, 1, 1, func_notdir_suffix), FT_ENTRY ("value", 0, 1, 1, func_value), -- 2.43.0
