[BACK]Return to operator.c CVS log [TXT] [DIR] Up to [Coherent Logic Development] / freem / src

Diff for /freem/src/operator.c between versions 1.1 and 1.5

version 1.1, 2025/01/19 02:04:04 version 1.5, 2025/03/09 19:50:47
Line 1 Line 1
 /*  /*
  *                            *   *   $Id$
  *                           * *  
  *                          *   *  
  *                     ***************  
  *                      * *       * *  
  *                       *  MUMPS  *  
  *                      * *       * *  
  *                     ***************  
  *                          *   *  
  *                           * *  
  *                            *  
  *  
  *   operator.c  
  *    operators pattern-match, divide, multiply, add, power   *    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) 1998 MUG Deutschland
  *    Copyright (C) 2020 Coherent Logic Development LLC   *    Copyright (C) 2020, 2025 Coherent Logic Development LLC
  *   *
  *   *
  *   This file is part of FreeM.   *   This file is part of FreeM.
Line 35 Line 23
  *   You should have received a copy of the GNU Affero Public License   *   You should have received a copy of the GNU Affero Public License
  *   along with FreeM.  If not, see <https://www.gnu.org/licenses/>.   *   along with FreeM.  If not, see <https://www.gnu.org/licenses/>.
  *   *
    *   $Log$
    *   Revision 1.5  2025/03/09 19:50:47  snw
    *   Second phase of REUSE compliance and header reformat
    *
    *
    * SPDX-FileCopyrightText:  (C) 2025 Coherent Logic Development LLC
    * SPDX-License-Identifier: AGPL-3.0-or-later
  **/   **/
   
 #include "mpsdef.h"  #include "mpsdef.h"
 #include <stdlib.h>  #include <stdlib.h>
 #include <math.h>  #include <math.h>
   
 void    root ();  
 void    mround ();  
 int unit (char *str);  int unit (char *str);
 extern void cond_round (char *a, int digits); /* defined in expr.c */  extern void cond_round (char *a, int digits); /* defined in expr.c */
   
Line 61  extern void cond_round (char *a, int dig Line 54  extern void cond_round (char *a, int dig
 #define NUMBASE 10  #define NUMBASE 10
   
 short int  short int
 pattern (a, b)                          /* evaluates a ? b */  pattern (char *a, char *b)                              /* evaluates a ? b */
         char   *a;  
         char   *b;  
   
 {  {
     short   levels;                     /* depth of stack */      short   levels;                     /* depth of stack */
     register int patx;                  /* match stack pointer */      register int patx;                  /* match stack pointer */
Line 486  pattern (a, b)    /* evaluates a ? b */ Line 476  pattern (a, b)    /* evaluates a ? b */
     }      }
     return '0';      return '0';
 }                                       /* end of pattern */  }                                       /* 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,      int     mininc,
             maxinc,              maxinc,
Line 592  pminmax (str, min, max)   /* auxiliary f Line 576  pminmax (str, min, max)   /* auxiliary f
     return;      return;
 }                                       /* end pminmax() */  }                                       /* end pminmax() */
 /******************************************************************************/  /******************************************************************************/
 void  void add (char *a, char *b)                             /* string arithmetic a+=b; */
 add (a, b)                              /* string arithmetic a+=b; */  
         char   *a,  
                *b;  
   
 {  {
           
     if (b[0] == ZERO)      if (b[0] == ZERO)
Line 853  add (a, b)    /* string arithmetic a+=b; Line 833  add (a, b)    /* string arithmetic a+=b;
     }      }
 }  }
 /******************************************************************************/  /******************************************************************************/
 void  void mul (char *a, char *b)                             /* string arithmetic a=a*b */
 mul (a, b)                              /* string arithmetic a=a*b */  
         char   *a,  
                *b;  
 {  {
     char    c[2*(STRLEN+1) /*was 512*/];      char    c[2*(STRLEN+1) /*was 512*/];
     short   alen,      short   alen,
Line 1101  mul (a, b)    /* string arithmetic a=a*b Line 1078  mul (a, b)    /* string arithmetic a=a*b
  * for a detailed description of the method for the divisions see             *   * for a detailed description of the method for the divisions see             *
  * donald e.knuth 'the art of computer programming' vol.2 p.257               *   * donald e.knuth 'the art of computer programming' vol.2 p.257               *
  ******************************************************************************/   ******************************************************************************/
 void  void mdiv (char *uu, char *v, short typ)                        /* divide string arithmetic */
 mdiv (uu, v, typ)                       /* divide string arithmetic */  
         char   *uu,                     /* dividend and result */  
                *v;                      /* divisor */  
         short   typ;                    /* type: '/' or '\' or '#' */  
   
 {  {
     char    q[STRLEN + 2 /*was 257*/];  /* quotient */      char    q[STRLEN + 2 /*was 257*/];  /* quotient */
     char    u[2*(STRLEN + 1)/*was 512*/];/* intermediate result */      char    u[2*(STRLEN + 1)/*was 512*/];/* intermediate result */
Line 1551  mdiv (uu, v, typ)   /* divide string ari Line 1523  mdiv (uu, v, typ)   /* divide string ari
     return;      return;
 }                                       /* end div() */  }                                       /* end div() */
 /******************************************************************************/  /******************************************************************************/
 void  void power (char *a, char *b)                           /* raise a to the b-th power */
 power (a, b)                            /* raise a to the b-th power */  
         char   *a,  
                *b;  
 {  {
     char    c[STRLEN + 2/*was 257*/];      char    c[STRLEN + 2/*was 257*/];
     char    d[4*(STRLEN + 1)/*was 1024*/];/* 257 should be sufficient, but somewhere there */      char    d[4*(STRLEN + 1)/*was 1024*/];/* 257 should be sufficient, but somewhere there */
Line 1767  power (a, b)    /* raise a to the b-th p Line 1736  power (a, b)    /* raise a to the b-th p
     return;      return;
 }                                       /* end power() */  }                                       /* end power() */
 /******************************************************************************/  /******************************************************************************/
 void  void g_sqrt (char *a)                           /* square root */
 g_sqrt (a)                              /* square root */  
         char   *a;  
   
 {  {
     register int i,      register int i,
             ch;              ch;
Line 1822  g_sqrt (a)    /* square root */ Line 1788  g_sqrt (a)    /* square root */
     }      }
 }                                       /* end g_sqrt() */  }                                       /* end g_sqrt() */
 /******************************************************************************/  /******************************************************************************/
 void  void root (char *a, long n)                             /* n.th root */
 root (a, n)                             /* n.th root */  
         char   *a;  
         long    n;  
   
 {  {
     register int i,      register int i,
             ch;              ch;
Line 1917  root (a, n)    /* n.th root */ Line 1879  root (a, n)    /* n.th root */
     }      }
 }                                       /* end root() */  }                                       /* end root() */
 /******************************************************************************/  /******************************************************************************/
 int  int numlit (char *str)
 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;  
 {  {
     long   j,      long   j,
             mi = 0,              mi = 0,
Line 2154  int unit (char *str) Line 2111  int unit (char *str)
     return 0;      return 0;
 }  }
 /******************************************************************************/  /******************************************************************************/
 long  long intexpr (char *str)
 intexpr (str)  
         char   *str;  
   
 /* 'str' is interpreted as integer and converted to int */  
 {  {
     {      {
         register int ch;          register int ch;
Line 2228  intexpr (str) Line 2181  intexpr (str)
     }      }
 }                                       /* end of intexpr */  }                                       /* end of intexpr */
 /******************************************************************************/  /******************************************************************************/
 short int  short int tvexpr (char *str)                            /* str is interpreted as truth valued expression */
 tvexpr (str)                            /* str is interpreted as truth valued expression */  
         char   *str;  
 {  {
     if (str[0] > ZERO && str[0] <= NINE) {      if (str[0] > ZERO && str[0] <= NINE) {
         str[0] = ONE;          str[0] = ONE;
Line 2270  tvexpr (str)    /* str is interpreted as Line 2221  tvexpr (str)    /* str is interpreted as
         }          }
     }      }
 }  }
   
 /******************************************************************************/  /******************************************************************************/
 void  void m_op (char *a, char *b, short op)
 m_op (a, b, op)  
         char   *a,  
                *b;  
         short   op;  
 {  {
     int     atyp,      int     atyp,
             btyp;                       /* DM/EUR currency types */              btyp;                       /* DM/EUR currency types */
Line 2556  m_op (a, b, op) Line 2504  m_op (a, b, op)
         /* rounding */          /* rounding */
         /* 'a' is assumed to be a 'canonic' numeric string  */          /* 'a' is assumed to be a 'canonic' numeric string  */
         /* it is rounded to 'digits' fractional digits      */          /* it is rounded to 'digits' fractional digits      */
 void  void mround (char *a, int digits)
 mround (a, digits)  
         char   *a;  
         int     digits;  
 {  {
     int     ch,      int     ch,
             i,              i,
Removed from v.1.1  
changed lines
  Added in v.1.5

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>