[BACK]Return to trace.c CVS log [TXT][DIR] Up to [local] / OpenXM_contrib / gmp / tests

Annotation of OpenXM_contrib/gmp/tests/trace.c, Revision 1.1

1.1     ! ohara       1: /* Support for diagnostic traces.
        !             2:
        !             3: Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
        !             4:
        !             5: This file is part of the GNU MP Library.
        !             6:
        !             7: The GNU MP Library is free software; you can redistribute it and/or modify
        !             8: it under the terms of the GNU Lesser General Public License as published by
        !             9: the Free Software Foundation; either version 2.1 of the License, or (at your
        !            10: option) any later version.
        !            11:
        !            12: The GNU MP Library is distributed in the hope that it will be useful, but
        !            13: WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
        !            14: or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
        !            15: License for more details.
        !            16:
        !            17: You should have received a copy of the GNU Lesser General Public License
        !            18: along with the GNU MP Library; see the file COPYING.LIB.  If not, write to
        !            19: the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
        !            20: MA 02111-1307, USA. */
        !            21:
        !            22:
        !            23: /* Future: Would like commas printed between limbs in hex or binary, but
        !            24:    perhaps not always since it might upset cutting and pasting into bc or
        !            25:    whatever.  */
        !            26:
        !            27:
        !            28: #include <stdio.h>
        !            29: #include <stdlib.h>
        !            30: #include <string.h> /* for strlen */
        !            31:
        !            32: #include "gmp.h"
        !            33: #include "gmp-impl.h"
        !            34:
        !            35: #include "tests.h"
        !            36:
        !            37:
        !            38: /* Number base for the various trace printing routines.
        !            39:    Set this in main() or with the debugger.
        !            40:    If hexadecimal is going to be fed into GNU bc, remember to use -16
        !            41:    because bc requires upper case.  */
        !            42:
        !            43: int  mp_trace_base = 10;
        !            44:
        !            45:
        !            46: void
        !            47: mp_trace_start (const char *name)
        !            48: {
        !            49:   if (name != NULL && name[0] != '\0')
        !            50:     printf ("%s=", name);
        !            51:
        !            52:   switch (ABS (mp_trace_base)) {
        !            53:   case  2: printf ("bin:");                         break;
        !            54:   case  8: printf ("oct:");                         break;
        !            55:   case 10:                                          break;
        !            56:   case 16: printf ("0x");                           break;
        !            57:   default: printf ("base%d:", ABS (mp_trace_base)); break;
        !            58:   }
        !            59: }
        !            60:
        !            61: /* Print "name=value\n" to stdout for an mpq_t value.  */
        !            62: void
        !            63: mpq_trace (const char *name, mpq_srcptr q)
        !            64: {
        !            65:   mp_trace_start (name);
        !            66:   if (q == NULL)
        !            67:     {
        !            68:       printf ("NULL\n");
        !            69:       return;
        !            70:     }
        !            71:
        !            72:   mpq_out_str (stdout, mp_trace_base, q);
        !            73:   printf ("\n");
        !            74: }
        !            75:
        !            76:
        !            77: /* Print "name=value\n" to stdout for an mpz_t value.  */
        !            78: void
        !            79: mpz_trace (const char *name, mpz_srcptr z)
        !            80: {
        !            81:   mpq_t      q;
        !            82:   mp_limb_t  one;
        !            83:
        !            84:   if (z == NULL)
        !            85:     {
        !            86:       mpq_trace (name, NULL);
        !            87:       return;
        !            88:     }
        !            89:
        !            90:   q->_mp_num._mp_alloc = ALLOC(z);
        !            91:   q->_mp_num._mp_size = SIZ(z);
        !            92:   q->_mp_num._mp_d = PTR(z);
        !            93:
        !            94:   one = 1;
        !            95:   q->_mp_den._mp_alloc = 1;
        !            96:   q->_mp_den._mp_size = 1;
        !            97:   q->_mp_den._mp_d = &one;
        !            98:
        !            99:   mpq_trace(name, q);
        !           100: }
        !           101:
        !           102:
        !           103: /* Print "name=value\n" to stdout for an mpf_t value. */
        !           104: void
        !           105: mpf_trace (const char *name, mpf_srcptr f)
        !           106: {
        !           107:   mp_trace_start (name);
        !           108:   if (f == NULL)
        !           109:     {
        !           110:       printf ("NULL\n");
        !           111:       return;
        !           112:     }
        !           113:
        !           114:   mpf_out_str (stdout, mp_trace_base, 0, f);
        !           115:   printf ("\n");
        !           116: }
        !           117:
        !           118:
        !           119: /* Print "namenum=value\n" to stdout for an mpz_t value.
        !           120:    "name" should have a "%d" to get the number. */
        !           121: void
        !           122: mpz_tracen (const char *name, int num, mpz_srcptr z)
        !           123: {
        !           124:   if (name != NULL && name[0] != '\0')
        !           125:     {
        !           126:       printf (name, num);
        !           127:       putchar ('=');
        !           128:     }
        !           129:   mpz_trace (NULL, z);
        !           130: }
        !           131:
        !           132:
        !           133: /* Print "name=value\n" to stdout for an mpn style ptr,size. */
        !           134: void
        !           135: mpn_trace (const char *name, mp_srcptr ptr, mp_size_t size)
        !           136: {
        !           137:   mpz_t  z;
        !           138:   if (ptr == NULL)
        !           139:     {
        !           140:       mpz_trace (name, NULL);
        !           141:       return;
        !           142:     }
        !           143:   MPN_NORMALIZE (ptr, size);
        !           144:   PTR(z) = (mp_ptr) ptr;
        !           145:   SIZ(z) = size;
        !           146:   ALLOC(z) = size;
        !           147:   mpz_trace (name, z);
        !           148: }
        !           149:
        !           150:
        !           151: /* Print "namenum=value\n" to stdout for an mpn style ptr,size.
        !           152:    "name" should have a "%d" to get the number.  */
        !           153: void
        !           154: mpn_tracen (const char *name, int num, mp_srcptr ptr, mp_size_t size)
        !           155: {
        !           156:   if (name != NULL && name[0] != '\0')
        !           157:     {
        !           158:       printf (name, num);
        !           159:       putchar ('=');
        !           160:     }
        !           161:   mpn_trace (NULL, ptr, size);
        !           162: }
        !           163:
        !           164:
        !           165: /* Print "namenum=value\n" to stdout for an array of mpn style ptr,size.
        !           166:
        !           167:    "a" is an array of pointers, each a[i] is a pointer to "size" many limbs.
        !           168:    The formal parameter isn't mp_srcptr because that causes compiler
        !           169:    warnings, but the values aren't modified.
        !           170:
        !           171:    "name" should have a printf style "%d" to get the array index.  */
        !           172:
        !           173: void
        !           174: mpn_tracea (const char *name, const mp_ptr *a, int count, mp_size_t size)
        !           175: {
        !           176:   int i;
        !           177:   for (i = 0; i < count; i++)
        !           178:     mpn_tracen (name, i, a[i], size);
        !           179: }
        !           180:
        !           181:
        !           182: /* Print "value\n" to a file for an mpz_t value.  Any previous contents of
        !           183:    the file are overwritten, so you need different file names each time this
        !           184:    is called.
        !           185:
        !           186:    Overwriting the file is a feature, it means you get old data replaced
        !           187:    when you run a test program repeatedly.  */
        !           188:
        !           189: void
        !           190: mpn_trace_file (const char *filename, mp_srcptr ptr, mp_size_t size)
        !           191: {
        !           192:   FILE   *fp;
        !           193:   mpz_t  z;
        !           194:
        !           195:   fp = fopen (filename, "w");
        !           196:   if (fp == NULL)
        !           197:     {
        !           198:       perror ("fopen");
        !           199:       abort();
        !           200:     }
        !           201:
        !           202:   MPN_NORMALIZE (ptr, size);
        !           203:   PTR(z) = (mp_ptr) ptr;
        !           204:   SIZ(z) = (int) size;
        !           205:
        !           206:   mpz_out_str (fp, mp_trace_base, z);
        !           207:   fprintf (fp, "\n");
        !           208:
        !           209:   if (ferror (fp) || fclose (fp) != 0)
        !           210:     {
        !           211:       printf ("error writing %s\n", filename);
        !           212:       abort();
        !           213:     }
        !           214: }
        !           215:
        !           216:
        !           217: /* Print "value\n" to a set of files, one file for each element of the given
        !           218:    array of mpn style ptr,size.  Any previous contents of the files are
        !           219:    overwritten, so you need different file names each time this is called.
        !           220:    Each file is "filenameN" where N is 0 to count-1.
        !           221:
        !           222:    "a" is an array of pointers, each a[i] is a pointer to "size" many limbs.
        !           223:    The formal parameter isn't mp_srcptr because that causes compiler
        !           224:    warnings, but the values aren't modified.
        !           225:
        !           226:    Overwriting the files is a feature, it means you get old data replaced
        !           227:    when you run a test program repeatedly.  The output style isn't
        !           228:    particularly pretty, but at least it gets something out, and you can cat
        !           229:    the files into bc, or whatever. */
        !           230:
        !           231: void
        !           232: mpn_tracea_file (const char *filename,
        !           233:                  const mp_ptr *a, int count, mp_size_t size)
        !           234: {
        !           235:   char  *s;
        !           236:   int   i;
        !           237:   TMP_DECL (marker);
        !           238:
        !           239:   TMP_MARK (marker);
        !           240:   s = (char *) TMP_ALLOC (strlen (filename) + 50);
        !           241:
        !           242:   for (i = 0; i < count; i++)
        !           243:     {
        !           244:       sprintf (s, "%s%d", filename, i);
        !           245:       mpn_trace_file (s, a[i], size);
        !           246:     }
        !           247:
        !           248:   TMP_FREE (marker);
        !           249: }
        !           250:
        !           251:
        !           252: void
        !           253: byte_trace (const char *name, const void *ptr, mp_size_t size)
        !           254: {
        !           255:   char       *fmt;
        !           256:   mp_size_t  i;
        !           257:
        !           258:   mp_trace_start (name);
        !           259:
        !           260:   switch (mp_trace_base) {
        !           261:   case   8: fmt = " %o"; break;
        !           262:   case  10: fmt = " %d"; break;
        !           263:   case  16: fmt = " %x"; break;
        !           264:   case -16: fmt = " %X"; break;
        !           265:   default: printf ("Oops, unsupported base in byte_trace\n"); abort (); break;
        !           266:   }
        !           267:
        !           268:   for (i = 0; i < size; i++)
        !           269:     printf (fmt, (int) ((unsigned char *) ptr)[i]);
        !           270:   printf ("\n");
        !           271: }
        !           272:
        !           273: void
        !           274: byte_tracen (const char *name, int num, const void *ptr, mp_size_t size)
        !           275: {
        !           276:   if (name != NULL && name[0] != '\0')
        !           277:     {
        !           278:       printf (name, num);
        !           279:       putchar ('=');
        !           280:     }
        !           281:   byte_trace (NULL, ptr, size);
        !           282: }

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