src/libs/mapm/mapmutl2.c

   1
   2 /*
   3  *  M_APM  -  mapmutl2.c
   4  *
   5  *  Copyright (C) 2002 - 2007   Michael C. Ring
   6  *
   7  *  Permission to use, copy, and distribute this software and its
   8  *  documentation for any purpose with or without fee is hereby granted,
   9  *  provided that the above copyright notice appear in all copies and
  10  *  that both that copyright notice and this permission notice appear
  11  *  in supporting documentation.
  12  *
  13  *  Permission to modify the software is granted. Permission to distribute
  14  *  the modified code is granted. Modifications are to be distributed by
  15  *  using the file 'license.txt' as a template to modify the file header.
  16  *  'license.txt' is available in the official MAPM distribution.
  17  *
  18  *  This software is provided "as is" without express or implied warranty.
  19  */
  20
  21 /*
  22  *      $Id: mapmutl2.c,v 1.7 2007/12/03 02:00:04 mike Exp $
  23  *
  24  *      This file contains various utility functions
  25  *
  26  *      $Log: mapmutl2.c,v $
  27  *      Revision 1.7  2007/12/03 02:00:04  mike
  28  *      Update license
  29  *
  30  *      Revision 1.6  2003/07/21 20:53:10  mike
  31  *      Modify error messages to be in a consistent format.
  32  *
  33  *      Revision 1.5  2003/05/04 18:14:32  mike
  34  *      move generic error handling function into a dedicated module
  35  *
  36  *      Revision 1.4  2003/03/31 22:02:22  mike
  37  *      call generic error handling function
  38  *
  39  *      Revision 1.3  2002/11/03 21:19:40  mike
  40  *      Updated function parameters to use the modern style
  41  *
  42  *      Revision 1.2  2002/05/17 22:29:46  mike
  43  *      update some comments
  44  *
  45  *      Revision 1.1  2002/05/17 22:28:27  mike
  46  *      Initial revision
  47  */
  48
  49 #include "m_apm_lc.h"
  50
  51 /****************************************************************************/
  52 int     m_apm_sign(M_APM atmp)
  53 {
  54 return(atmp->m_apm_sign);
  55 }
  56 /****************************************************************************/
  57 int     m_apm_exponent(M_APM atmp)
  58 {
  59 if (atmp->m_apm_sign == 0)
  60   return(0);
  61 else
  62   return(atmp->m_apm_exponent - 1);
  63 }
  64 /****************************************************************************/
  65 int     m_apm_significant_digits(M_APM atmp)
  66 {
  67 return(atmp->m_apm_datalength);
  68 }
  69 /****************************************************************************/
  70 int     m_apm_is_integer(M_APM atmp)
  71 {
  72 if (atmp->m_apm_sign == 0)
  73   return(1);
  74
  75 if (atmp->m_apm_exponent >= atmp->m_apm_datalength)
  76   return(1);
  77 else
  78   return(0);
  79 }
  80 /****************************************************************************/
  81 int     m_apm_is_even(M_APM aa)
  82 {
  83 int     ii, jj;
  84
  85 if (aa->m_apm_sign == 0)
  86   return(1);
  87
  88 ii = aa->m_apm_datalength;
  89 jj = aa->m_apm_exponent;
  90
  91 if (jj < ii)
  92   {
  93    M_apm_log_error_msg(M_APM_RETURN, "\'m_apm_is_even\', Non-integer input");
  94    return(0);
  95   }
  96
  97 if (jj > ii)
  98   return(1);
  99
 100 ii = ((ii + 1) >> 1) - 1;
 101 ii = (int)aa->m_apm_data[ii];
 102
 103 if ((jj & 1) != 0)      /* exponent is odd */
 104   ii = ii / 10;
 105
 106 if ((ii & 1) == 0)
 107   return(1);
 108 else
 109   return(0);
 110 }
 111 /****************************************************************************/
 112 int     m_apm_is_odd(M_APM bb)
 113 {
 114 if (m_apm_is_even(bb))
 115   return(0);
 116 else
 117   return(1);
 118 }
 119 /****************************************************************************/
 120 void    M_set_to_zero(M_APM z)
 121 {
 122 z->m_apm_datalength = 1;
 123 z->m_apm_sign       = 0;
 124 z->m_apm_exponent   = 0;
 125 z->m_apm_data[0]    = 0;
 126 }
 127 /****************************************************************************/
 128 void    m_apm_negate(M_APM d, M_APM s)
 129 {
 130 m_apm_copy(d,s);
 131 if (d->m_apm_sign != 0)
 132     d->m_apm_sign = -(d->m_apm_sign);
 133 }
 134 /****************************************************************************/
 135 void    m_apm_absolute_value(M_APM d, M_APM s)
 136 {
 137 m_apm_copy(d,s);
 138 if (d->m_apm_sign != 0)
 139     d->m_apm_sign = 1;
 140 }
 141 /****************************************************************************/
 142 void    m_apm_copy(M_APM dest, M_APM src)
 143 {
 144 int     j;
 145 void    *vp;
 146
 147 j = (src->m_apm_datalength + 1) >> 1;
 148 if (j > dest->m_apm_malloclength)
 149   {
 150    if ((vp = MAPM_REALLOC(dest->m_apm_data, (j + 32))) == NULL)
 151      {
 152       /* fatal, this does not return */
 153
 154       M_apm_log_error_msg(M_APM_FATAL, "\'m_apm_copy\', Out of memory");
 155      }
 156
 157    dest->m_apm_malloclength = j + 28;
 158    dest->m_apm_data = (UCHAR *)vp;
 159   }
 160
 161 dest->m_apm_datalength = src->m_apm_datalength;
 162 dest->m_apm_exponent   = src->m_apm_exponent;
 163 dest->m_apm_sign       = src->m_apm_sign;
 164
 165 memcpy(dest->m_apm_data, src->m_apm_data, j);
 166 }
 167 /****************************************************************************/
 168 int     m_apm_compare(M_APM ltmp, M_APM rtmp)
 169 {
 170 int     llen, rlen, lsign, rsign, i, j, lexp, rexp;
 171
 172 llen  = ltmp->m_apm_datalength;
 173 rlen  = rtmp->m_apm_datalength;
 174
 175 lsign = ltmp->m_apm_sign;
 176 rsign = rtmp->m_apm_sign;
 177
 178 lexp  = ltmp->m_apm_exponent;
 179 rexp  = rtmp->m_apm_exponent;
 180
 181 if (rsign == 0)
 182   return(lsign);
 183
 184 if (lsign == 0)
 185   return(-rsign);
 186
 187 if (lsign == -rsign)
 188   return(lsign);
 189
 190 /* signs are the same, check the exponents */
 191
 192 if (lexp > rexp)
 193   goto E1;
 194
 195 if (lexp < rexp)
 196   goto E2;
 197
 198 /* signs and exponents are the same, check the data */
 199
 200 if (llen < rlen)
 201   j = (llen + 1) >> 1;
 202 else
 203   j = (rlen + 1) >> 1;
 204
 205 for (i=0; i < j; i++)
 206   {
 207    if (ltmp->m_apm_data[i] > rtmp->m_apm_data[i])
 208      goto E1;
 209
 210    if (ltmp->m_apm_data[i] < rtmp->m_apm_data[i])
 211      goto E2;
 212   }
 213
 214 if (llen == rlen)
 215    return(0);
 216 else
 217   {
 218    if (llen > rlen)
 219      goto E1;
 220    else
 221      goto E2;
 222   }
 223
 224 E1:
 225
 226 if (lsign == 1)
 227   return(1);
 228 else
 229   return(-1);
 230
 231 E2:
 232
 233 if (lsign == 1)
 234   return(-1);
 235 else
 236   return(1);
 237 }
 238 /****************************************************************************/
 239 /*
 240  *
 241  *      convert a signed long int to ASCII in base 10
 242  *
 243  */
 244 void    M_long_2_ascii(char *output, long input)
 245 {
 246 long    t, m;
 247 int     i, j;
 248 char    *p, tbuf[64];
 249
 250 m = input;
 251 p = output;
 252 i = 0;
 253 t = 2147000000L;          /* something < 2^31 */
 254
 255 if ((m > t) || (m < -t))  /* handle the bigger numbers with 'sprintf'. */
 256   {                       /* let them worry about wrap-around problems */
 257    sprintf(p, "%ld", m);  /* at 'LONG_MIN', etc.                       */
 258   }
 259 else
 260   {
 261    if (m < 0)             /* handle the sign */
 262      {
 263       *p++ = '-';
 264       m = -m;
 265      }
 266
 267    while (TRUE)           /* build the digits in reverse order */
 268      {
 269       t = m / 10;
 270       j = (int)(m - (10 * t));
 271       tbuf[i++] = (char)(j + '0');
 272       m = t;
 273
 274       if (t == 0)
 275         break;
 276      }
 277
 278    while (TRUE)           /* fill output string in the correct order */
 279      {
 280       *p++ = tbuf[--i];
 281       if (i == 0)
 282         break;
 283      }
 284
 285    *p = '\0';
 286   }
 287 }
 288 /****************************************************************************/
 289 /*
 290  *      this function will convert a string to lowercase
 291  */
 292 char    *M_lowercase(char *s)
 293 {
 294 char    *p;
 295
 296 p = s;
 297
 298 while (TRUE)
 299   {
 300    if (*p >= 'A' && *p <= 'Z')
 301      *p += 'a' - 'A';
 302
 303    if (*p++ == '\0')  break;
 304   }
 305 return(s);
 306 }
 307 /****************************************************************************/
 308 /*    returns char position of first occurence of s2 in s1
 309           or -1 if no match found
 310 */
 311 int     M_strposition(char *s1, char *s2)
 312 {
 313 register char  ch1, ch2;
 314 char           *p0, *p1, *p2;
 315 int            ct;
 316
 317 ct = -1;
 318 p0 = s1;
 319
 320 if (*s2 == '\0')  return(-1);
 321
 322 while (TRUE)
 323   {
 324    ct++;
 325    p1  = p0;
 326    p2  = s2;
 327    ch2 = *p2;
 328
 329    while (TRUE)                    /* scan until first char matches */
 330      {
 331       if ((ch1 = *p1) == '\0')  return(-1);
 332       if (ch1 == ch2)           break;
 333       p1++;
 334       ct++;
 335      }
 336
 337    p2++;                           /* check remainder of 2 strings */
 338    p1++;
 339    p0 = p1;
 340
 341    while (TRUE)
 342      {
 343       if ((ch2 = *p2) == '\0')  return(ct);
 344       if (*p1 != ch2)           break;
 345       p1++;
 346       p2++;
 347      }
 348   }
 349 }
 350 /****************************************************************************/