--- freem/src/operator.c	2025/01/19 02:04:04	1.1.1.1
+++ freem/src/operator.c	2025/03/09 15:20:18	1.4
@@ -15,7 +15,7 @@
  *    operators pattern-match, divide, multiply, add, power
  *
  *  
- *   Author: Serena Willis <jpw@coherent-logic.com>
+ *   Author: Serena Willis <snw@coherent-logic.com>
  *    Copyright (C) 1998 MUG Deutschland
  *    Copyright (C) 2020 Coherent Logic Development LLC
  *
@@ -41,8 +41,6 @@
 #include <stdlib.h>
 #include <math.h>
 
-void    root ();
-void    mround ();
 int unit (char *str);
 extern void cond_round (char *a, int digits); /* defined in expr.c */
 
@@ -61,10 +59,7 @@ extern void cond_round (char *a, int dig
 #define NUMBASE	10
 
 short int
-pattern (a, b)				/* evaluates a ? b */
-	char   *a;
-	char   *b;
-
+pattern (char *a, char *b)				/* evaluates a ? b */
 {
     short   levels;			/* depth of stack */
     register int patx;			/* match stack pointer */
@@ -486,15 +481,9 @@ pattern (a, b)				/* evaluates a ? b */
     }
     return '0';
 }					/* end of pattern */
-/******************************************************************************/
-void
-pminmax (str, min, max)			/* auxiliary function for grouped pattern match */
-
-/* determines                                   */
-	char   *str;			/* of a pattern 'str'                           */
-	int    *min,
-	       *max;			/* the minimum and maximum possible length      */
 
+/******************************************************************************/
+void pminmax (char *str, int *min, int *max)
 {
     int     mininc,
             maxinc,
@@ -592,11 +581,7 @@ pminmax (str, min, max)			/* auxiliary f
     return;
 }					/* end pminmax() */
 /******************************************************************************/
-void
-add (a, b)				/* string arithmetic a+=b; */
-	char   *a,
-	       *b;
-
+void add (char *a, char *b)				/* string arithmetic a+=b; */
 {
     
     if (b[0] == ZERO)
@@ -853,10 +838,7 @@ add (a, b)				/* string arithmetic a+=b;
     }
 }
 /******************************************************************************/
-void
-mul (a, b)				/* string arithmetic a=a*b */
-	char   *a,
-	       *b;
+void mul (char *a, char *b)				/* string arithmetic a=a*b */
 {
     char    c[2*(STRLEN+1) /*was 512*/];
     short   alen,
@@ -1101,12 +1083,7 @@ mul (a, b)				/* string arithmetic a=a*b
  * for a detailed description of the method for the divisions see             *
  * donald e.knuth 'the art of computer programming' vol.2 p.257               *
  ******************************************************************************/
-void
-mdiv (uu, v, typ)			/* divide string arithmetic */
-	char   *uu,			/* dividend and result */
-	       *v;			/* divisor */
-	short   typ;			/* type: '/' or '\' or '#' */
-
+void mdiv (char *uu, char *v, short typ)			/* divide string arithmetic */
 {
     char    q[STRLEN + 2 /*was 257*/];	/* quotient */
     char    u[2*(STRLEN + 1)/*was 512*/];/* intermediate result */
@@ -1551,10 +1528,7 @@ mdiv (uu, v, typ)			/* divide string ari
     return;
 }					/* end div() */
 /******************************************************************************/
-void
-power (a, b)				/* raise a to the b-th power */
-	char   *a,
-	       *b;
+void power (char *a, char *b)				/* raise a to the b-th power */
 {
     char    c[STRLEN + 2/*was 257*/];
     char    d[4*(STRLEN + 1)/*was 1024*/];/* 257 should be sufficient, but somewhere there */
@@ -1767,10 +1741,7 @@ power (a, b)				/* raise a to the b-th p
     return;
 }					/* end power() */
 /******************************************************************************/
-void
-g_sqrt (a)				/* square root */
-	char   *a;
-
+void g_sqrt (char *a)				/* square root */
 {
     register int i,
             ch;
@@ -1822,11 +1793,7 @@ g_sqrt (a)				/* square root */
     }
 }					/* end g_sqrt() */
 /******************************************************************************/
-void
-root (a, n)				/* n.th root */
-	char   *a;
-	long    n;
-
+void root (char *a, long n)				/* n.th root */
 {
     register int i,
             ch;
@@ -1917,12 +1884,7 @@ root (a, n)				/* n.th root */
     }
 }					/* end root() */
 /******************************************************************************/
-int
-numlit (str)
-/** str is interpreted as a MUMPS number
-					 * and is converted to canonical form
-					 * return value: 1=EUR, 4=DM, 0=other */
-	char   *str;
+int numlit (char *str)
 {
     long   j,
             mi = 0,
@@ -2154,11 +2116,7 @@ int unit (char *str)
     return 0;
 }
 /******************************************************************************/
-long
-intexpr (str)
-	char   *str;
-
-/* 'str' is interpreted as integer and converted to int */
+long intexpr (char *str)
 {
     {
 	register int ch;
@@ -2228,9 +2186,7 @@ intexpr (str)
     }
 }					/* end of intexpr */
 /******************************************************************************/
-short int
-tvexpr (str)				/* str is interpreted as truth valued expression */
-	char   *str;
+short int tvexpr (char *str)				/* str is interpreted as truth valued expression */
 {
     if (str[0] > ZERO && str[0] <= NINE) {
 	str[0] = ONE;
@@ -2270,12 +2226,9 @@ tvexpr (str)				/* str is interpreted as
 	}
     }
 }
+
 /******************************************************************************/
-void
-m_op (a, b, op)
-	char   *a,
-	       *b;
-	short   op;
+void m_op (char *a, char *b, short op)
 {
     int     atyp,
             btyp;			/* DM/EUR currency types */
@@ -2556,10 +2509,7 @@ m_op (a, b, op)
 	/* rounding */
 	/* 'a' is assumed to be a 'canonic' numeric string  */
 	/* it is rounded to 'digits' fractional digits      */
-void
-mround (a, digits)
-	char   *a;
-	int     digits;
+void mround (char *a, int digits)
 {
     int     ch,
             i,