doscan.c
上传用户:qaz666999
上传日期:2022-08-06
资源大小:2570k
文件大小:20k
源码类别:

数学计算

开发平台:

Unix_Linux

  1. /* __gmp_doscan -- formatted input internals.
  2.    THE FUNCTIONS IN THIS FILE ARE FOR INTERNAL USE ONLY.  THEY'RE ALMOST
  3.    CERTAIN TO BE SUBJECT TO INCOMPATIBLE CHANGES OR DISAPPEAR COMPLETELY IN
  4.    FUTURE GNU MP RELEASES.
  5. Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
  6. This file is part of the GNU MP Library.
  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 3 of the License, or (at your
  10. option) any later version.
  11. The GNU MP Library is distributed in the hope that it will be useful, but
  12. WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13. or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  14. License for more details.
  15. You should have received a copy of the GNU Lesser General Public License
  16. along with the GNU MP Library.  If not, see http://www.gnu.org/licenses/.  */
  17. #define _GNU_SOURCE    /* for DECIMAL_POINT in langinfo.h */
  18. #include "config.h"
  19. #if HAVE_STDARG
  20. #include <stdarg.h>
  21. #else
  22. #include <varargs.h>
  23. #endif
  24. #include <ctype.h>
  25. #include <stddef.h>    /* for ptrdiff_t */
  26. #include <stdio.h>
  27. #include <stdlib.h>    /* for strtol */
  28. #include <string.h>
  29. #if HAVE_LANGINFO_H
  30. #include <langinfo.h>  /* for nl_langinfo */
  31. #endif
  32. #if HAVE_LOCALE_H
  33. #include <locale.h>    /* for localeconv */
  34. #endif
  35. #if HAVE_INTTYPES_H
  36. # include <inttypes.h> /* for intmax_t */
  37. #else
  38. # if HAVE_STDINT_H
  39. #  include <stdint.h>
  40. # endif
  41. #endif
  42. #if HAVE_SYS_TYPES_H
  43. #include <sys/types.h> /* for quad_t */
  44. #endif
  45. #include "gmp.h"
  46. #include "gmp-impl.h"
  47. /* Change this to "#define TRACE(x) x" for some traces. */
  48. #define TRACE(x)
  49. /* General:
  50.        It's necessary to parse up the format string to recognise the GMP
  51.        extra types F, Q and Z.  Other types and conversions are passed
  52.        across to the standard sscanf or fscanf via funs->scan, for ease of
  53.        implementation.  This is essential in the case of something like glibc
  54.        %p where the pointer format isn't actually documented.
  55.        Because funs->scan doesn't get the whole input it can't put the right
  56.        values in for %n, so that's handled in __gmp_doscan.  Neither sscanf
  57.        nor fscanf directly indicate how many characters were read, so an
  58.        extra %n is appended to each run for that.  For fscanf this merely
  59.        supports our %n output, but for sscanf it lets funs->step move us
  60.        along the input string.
  61.        Whitespace and literal matches in the format string, including %%,
  62.        are handled directly within __gmp_doscan.  This is reasonably
  63.        efficient, and avoids some suspicious behaviour observed in various
  64.        system libc's.  GLIBC 2.2.4 for instance returns 0 on
  65.    sscanf(" ", " x")
  66.        or
  67.    sscanf(" ", " x%d",&n)
  68.        whereas we think they should return EOF, since end-of-string is
  69.        reached when a match of "x" is required.
  70.        For standard % conversions, funs->scan is called once for each
  71.        conversion.  If we had vfscanf and vsscanf and could rely on their
  72.        fixed text matching behaviour then we could call them with multiple
  73.        consecutive standard conversions.  But plain fscanf and sscanf work
  74.        fine, and parsing one field at a time shouldn't be too much of a
  75.        slowdown.
  76.    gmpscan:
  77.        gmpscan reads a gmp type.  It's only used from one place, but is a
  78.        separate subroutine to avoid a big chunk of complicated code in the
  79.        middle of __gmp_doscan.  Within gmpscan a couple of loopbacks make it
  80.        possible to share code for parsing integers, rationals and floats.
  81.        In gmpscan normally one char of lookahead is maintained, but when width
  82.        is reached that stops, on the principle that an fgetc/ungetc of a char
  83.        past where we're told to stop would be undesirable.  "chars" is how many
  84.        characters have been read so far, including the current c.  When
  85.        chars==width and another character is desired then a jump is done to the
  86.        "convert" stage.  c is invalid and mustn't be unget'ed in this case;
  87.        chars is set to width+1 to indicate that.
  88.        gmpscan normally returns the number of characters read.  -1 means an
  89.        invalid field, -2 means EOF reached before any matching characters
  90.        were read.
  91.        For hex floats, the mantissa part is passed to mpf_set_str, then the
  92.        exponent is applied with mpf_mul_exp or mpf_div_2exp.  This is easier
  93.        than teaching mpf_set_str about an exponent factor (ie. 2) differing
  94.        from the mantissa radix point factor (ie. 16).  mpf_mul_exp and
  95.        mpf_div_2exp will preserve the application requested precision, so
  96.        nothing in that respect is lost by making this a two-step process.
  97.    Matching and errors:
  98.        C99 7.19.6.2 paras 9 and 10 say an input item is read as the longest
  99.        string which is a match for the appropriate type, or a prefix of a
  100.        match.  With that done, if it's only a prefix then the result is a
  101.        matching failure, ie. invalid input.
  102.        This rule seems fairly clear, but doesn't seem to be universally
  103.        applied in system C libraries.  Even GLIBC doesn't seem to get it
  104.        right, insofar as it seems to accept some apparently invalid forms.
  105.        Eg. glibc 2.3.1 accepts "0x" for a "%i", where a reading of the
  106.        standard would suggest a non-empty sequence of digits should be
  107.        required after an "0x".
  108.        A footnote to 7.19.6.2 para 17 notes how this input item reading can
  109.        mean inputs acceptable to strtol are not acceptable to fscanf.  We
  110.        think this confirms our reading of "0x" as invalid.
  111.        Clearly gmp_sscanf could backtrack to a longest input which was a
  112.        valid match for a given item, but this is not done, since C99 says
  113.        sscanf is identical to fscanf, so we make gmp_sscanf identical to
  114.        gmp_fscanf.
  115.    Types:
  116.        C99 says "ll" is for long long, and "L" is for long double floats.
  117.        Unfortunately in GMP 4.1.1 we documented the two as equivalent.  This
  118.        doesn't affect us directly, since both are passed through to plain
  119.        scanf.  It seems wisest not to try to enforce the C99 rule.  This is
  120.        consistent with what we said before, though whether it actually
  121.        worked was always up to the C library.
  122.    Alternatives:
  123.        Consideration was given to using separate code for gmp_fscanf and
  124.        gmp_sscanf.  The sscanf case could zip across a string doing literal
  125.        matches or recognising digits in gmpscan, rather than making a
  126.        function call fun->get per character.  The fscanf could use getc
  127.        rather than fgetc too, which might help those systems where getc is a
  128.        macro or otherwise inlined.  But none of this scanning and converting
  129.        will be particularly fast, so the two are done together to keep it a
  130.        little simpler for now.
  131.        Various multibyte string issues are not addressed, for a start C99
  132.        scanf says the format string is multibyte.  Since we pass %c, %s and
  133.        %[ to the system scanf, they might do multibyte reads already, but
  134.        it's another matter whether or not that can be used, since our digit
  135.        and whitespace parsing is only unibyte.  The plan is to quietly
  136.        ignore multibyte locales for now.  This is not as bad as it sounds,
  137.        since GMP is presumably used mostly on numbers, which can be
  138.        perfectly adequately treated in plain ASCII.
  139. */
  140. struct gmp_doscan_params_t {
  141.   int base;
  142.   int ignore;
  143.   char type;
  144.   int width;
  145. };
  146. #define GET(c)
  147.   do {
  148.     ASSERT (chars <= width);
  149.     chars++;
  150.     if (chars > width)
  151.       goto convert;
  152.     (c) = (*funs->get) (data);
  153.   } while (0)
  154. /* store into "s", extending if necessary */
  155. #define STORE(c)
  156.   do {
  157.     ASSERT (s_upto <= s_alloc);
  158.     if (s_upto >= s_alloc)
  159.       {
  160. size_t s_alloc_new = s_alloc + S_ALLOC_STEP;
  161. s = __GMP_REALLOCATE_FUNC_TYPE (s, s_alloc, s_alloc_new, char); 
  162. s_alloc = s_alloc_new;
  163.       }
  164.     s[s_upto++] = c;
  165.   } while (0)
  166. #define S_ALLOC_STEP  512
  167. static int
  168. gmpscan (const struct gmp_doscan_funs_t *funs, void *data,
  169.  const struct gmp_doscan_params_t *p, void *dst)
  170. {
  171.   int   chars, c, base, first, width, seen_point, seen_digit, hexfloat;
  172.   size_t  s_upto, s_alloc, hexexp;
  173.   char   *s;
  174.   int   invalid = 0;
  175.   TRACE (printf ("gmpscann"));
  176.   ASSERT (p->type == 'F' || p->type == 'Q' || p->type == 'Z');
  177.   c = (*funs->get) (data);
  178.   if (c == EOF)
  179.     return -2;
  180.   chars = 1;
  181.   first = 1;
  182.   seen_point = 0;
  183.   width = (p->width == 0 ? INT_MAX-1 : p->width);
  184.   base = p->base;
  185.   s_alloc = S_ALLOC_STEP;
  186.   s = __GMP_ALLOCATE_FUNC_TYPE (s_alloc, char);
  187.   s_upto = 0;
  188.   hexfloat = 0;
  189.   hexexp = 0;
  190.  another:
  191.   seen_digit = 0;
  192.   if (c == '-')
  193.     {
  194.       STORE (c);
  195.       goto get_for_sign;
  196.     }
  197.   else if (c == '+')
  198.     {
  199.       /* don't store '+', it's not accepted by mpz_set_str etc */
  200.     get_for_sign:
  201.       GET (c);
  202.     }
  203.   if (base == 0)
  204.     {
  205.       base = 10;   /* decimal if no base indicator */
  206.       if (c == '0')
  207. {
  208.   seen_digit = 1;   /* 0 alone is a valid number */
  209.   if (p->type != 'F')
  210.     base = 8;   /* leading 0 is octal, for non-floats */
  211.   STORE (c);
  212.   GET (c);
  213.   if (c == 'x' || c == 'X')
  214.     {
  215.       base = 16;
  216.       seen_digit = 0;   /* must have digits after an 0x */
  217.       if (p->type == 'F') /* don't pass 'x' to mpf_set_str_point */
  218. hexfloat = 1;
  219.       else
  220. STORE (c);
  221.       GET (c);
  222.     }
  223. }
  224.     }
  225.  digits:
  226.   for (;;)
  227.     {
  228.       if (base == 16)
  229. {
  230.   if (! isxdigit (c))
  231.     break;
  232. }
  233.       else
  234. {
  235.   if (! isdigit (c))
  236.     break;
  237.   if (base == 8 && (c == '8' || c == '9'))
  238.     break;
  239. }
  240.       seen_digit = 1;
  241.       STORE (c);
  242.       GET (c);
  243.     }
  244.   if (first)
  245.     {
  246.       /* decimal point */
  247.       if (p->type == 'F' && ! seen_point)
  248. {
  249.   /* For a multi-character decimal point, if the first character is
  250.      present then all of it must be, otherwise the input is
  251.      considered invalid.  */
  252.   const char  *point = GMP_DECIMAL_POINT;
  253.   int       pc = (unsigned char) *point++;
  254.   if (c == pc)
  255.     {
  256.       for (;;)
  257. {
  258.   STORE (c);
  259.   GET (c);
  260.   pc = (unsigned char) *point++;
  261.   if (pc == '')
  262.     break;
  263.   if (c != pc)
  264.     goto set_invalid;
  265. }
  266.       seen_point = 1;
  267.       goto digits;
  268.     }
  269. }
  270.       /* exponent */
  271.       if (p->type == 'F')
  272. {
  273.   if (hexfloat && (c == 'p' || c == 'P'))
  274.     {
  275.       hexexp = s_upto; /* exponent location */
  276.       base = 10;       /* exponent in decimal */
  277.       goto exponent;
  278.     }
  279.   else if (! hexfloat && (c == 'e' || c == 'E'))
  280.     {
  281.     exponent:
  282.       /* must have at least one digit in the mantissa, just an exponent
  283.  is not good enough */
  284.       if (! seen_digit)
  285. goto set_invalid;
  286.     do_second:
  287.       first = 0;
  288.       STORE (c);
  289.       GET (c);
  290.       goto another;
  291.     }
  292. }
  293.       /* denominator */
  294.       if (p->type == 'Q' && c == '/')
  295. {
  296.   /* must have at least one digit in the numerator */
  297.   if (! seen_digit)
  298.     goto set_invalid;
  299.   /* now look for at least one digit in the denominator */
  300.   seen_digit = 0;
  301.   /* allow the base to be redetermined for "%i" */
  302.   base = p->base;
  303.   goto do_second;
  304. }
  305.     }
  306.  convert:
  307.   if (! seen_digit)
  308.     {
  309.     set_invalid:
  310.       invalid = 1;
  311.       goto done;
  312.     }
  313.   if (! p->ignore)
  314.     {
  315.       STORE ('');
  316.       TRACE (printf (" convert "%s"n", s));
  317.       /* We ought to have parsed out a valid string above, so just test
  318.  mpz_set_str etc with an ASSERT.  */
  319.       switch (p->type) {
  320.       case 'F':
  321. {
  322.   mpf_ptr  f = (mpf_ptr) dst;
  323.   if (hexexp != 0)
  324.     s[hexexp] = '';
  325.   ASSERT_NOCARRY (mpf_set_str (f, s, hexfloat ? 16 : 10));
  326.   if (hexexp != 0)
  327.     {
  328.       char *dummy;
  329.       long  exp;
  330.       exp = strtol (s + hexexp + 1, &dummy, 10);
  331.       if (exp >= 0)
  332. mpf_mul_2exp (f, f, (unsigned long) exp);
  333.       else
  334. mpf_div_2exp (f, f, - (unsigned long) exp);
  335.     }
  336. }
  337. break;
  338.       case 'Q':
  339. ASSERT_NOCARRY (mpq_set_str ((mpq_ptr) dst, s, p->base));
  340. break;
  341.       case 'Z':
  342. ASSERT_NOCARRY (mpz_set_str ((mpz_ptr) dst, s, p->base));
  343. break;
  344.       default:
  345. ASSERT (0);
  346. /*FALLTHRU*/
  347. break;
  348.       }
  349.     }
  350.  done:
  351.   ASSERT (chars <= width+1);
  352.   if (chars != width+1)
  353.     {
  354.       (*funs->unget) (c, data);
  355.       TRACE (printf (" ungetc %d, to give %d charsn", c, chars-1));
  356.     }
  357.   chars--;
  358.   (*__gmp_free_func) (s, s_alloc);
  359.   if (invalid)
  360.     {
  361.       TRACE (printf (" invalidn"));
  362.       return -1;
  363.     }
  364.   TRACE (printf ("  return %d chars (cf width %d)n", chars, width));
  365.   return chars;
  366. }
  367. /* Read and discard whitespace, if any.  Return number of chars skipped.
  368.    Whitespace skipping never provokes the EOF return from __gmp_doscan, so
  369.    it's not necessary to watch for EOF from funs->get, */
  370. static int
  371. skip_white (const struct gmp_doscan_funs_t *funs, void *data)
  372. {
  373.   int  c;
  374.   int  ret = 0;
  375.   do
  376.     {
  377.       c = (funs->get) (data);
  378.       ret++;
  379.     }
  380.   while (isspace (c));
  381.   (funs->unget) (c, data);
  382.   ret--;
  383.   TRACE (printf ("  skip white %dn", ret));
  384.   return ret;
  385. }
  386. int
  387. __gmp_doscan (const struct gmp_doscan_funs_t *funs, void *data,
  388.       const char *orig_fmt, va_list orig_ap)
  389. {
  390.   struct gmp_doscan_params_t  param;
  391.   va_list     ap;
  392.   char       *alloc_fmt;
  393.   const char  *fmt, *this_fmt, *end_fmt;
  394.   size_t      orig_fmt_len, alloc_fmt_size, len;
  395.   int       new_fields, new_chars;
  396.   char       fchar;
  397.   int       fields = 0;
  398.   int       chars = 0;
  399.   TRACE (printf ("__gmp_doscan "%s"n", orig_fmt);
  400.  if (funs->scan == (gmp_doscan_scan_t) sscanf)
  401.    printf ("  s="%s"n", * (const char **) data));
  402.   /* Don't modify orig_ap, if va_list is actually an array and hence call by
  403.      reference.  It could be argued that it'd be more efficient to leave
  404.      callers to make a copy if they care, but doing so here is going to be a
  405.      very small part of the total work, and we may as well keep applications
  406.      out of trouble.  */
  407.   va_copy (ap, orig_ap);
  408.   /* Parts of the format string are going to be copied so that a " %n" can
  409.      be appended.  alloc_fmt is some space for that.  orig_fmt_len+4 will be
  410.      needed if fmt consists of a single "%" specifier, but otherwise is an
  411.      overestimate.  We're not going to be very fast here, so use
  412.      __gmp_allocate_func rather than TMP_ALLOC.  */
  413.   orig_fmt_len = strlen (orig_fmt);
  414.   alloc_fmt_size = orig_fmt_len + 4;
  415.   alloc_fmt = __GMP_ALLOCATE_FUNC_TYPE (alloc_fmt_size, char);
  416.   fmt = orig_fmt;
  417.   end_fmt = orig_fmt + orig_fmt_len;
  418.   for (;;)
  419.     {
  420.     next:
  421.       fchar = *fmt++;
  422.       if (fchar == '')
  423. break;
  424.       if (isspace (fchar))
  425. {
  426.   chars += skip_white (funs, data);
  427.   continue;
  428. }
  429.       if (fchar != '%')
  430. {
  431.   int  c;
  432. literal:
  433.   c = (funs->get) (data);
  434.   if (c != fchar)
  435.     {
  436.       (funs->unget) (c, data);
  437.       if (c == EOF)
  438. {
  439. eof_no_match:
  440.   if (fields == 0)
  441.     fields = EOF;
  442. }
  443.       goto done;
  444.     }
  445.   chars++;
  446.   continue;
  447. }
  448.       param.type = '';
  449.       param.base = 0;  /* for e,f,g,i */
  450.       param.ignore = 0;
  451.       param.width = 0;
  452.       this_fmt = fmt-1;
  453.       TRACE (printf (" this_fmt "%s"n", this_fmt));
  454.       for (;;)
  455. {
  456.   ASSERT (fmt <= end_fmt);
  457.   fchar = *fmt++;
  458.   switch (fchar) {
  459.   case '':  /* unterminated % sequence */
  460.     ASSERT (0);
  461.     goto done;
  462.   case '%':   /* literal % */
  463.     goto literal;
  464.   case '[':   /* character range */
  465.     fchar = *fmt++;
  466.     if (fchar == '^')
  467.       fchar = *fmt++;
  468.     /* ']' allowed as the first char (possibly after '^') */
  469.     if (fchar == ']')
  470.       fchar = *fmt++;
  471.     for (;;)
  472.       {
  473. ASSERT (fmt <= end_fmt);
  474. if (fchar == '')
  475.   {
  476.     /* unterminated % sequence */
  477.     ASSERT (0);
  478.     goto done;
  479.   }
  480. if (fchar == ']')
  481.   break;
  482. fchar = *fmt++;
  483.       }
  484.     /*FALLTHRU*/
  485.   case 'c':   /* characters */
  486.   case 's':   /* string of non-whitespace */
  487.   case 'p':   /* pointer */
  488.   libc_type:
  489.     len = fmt - this_fmt;
  490.     memcpy (alloc_fmt, this_fmt, len);
  491.     alloc_fmt[len++] = '%';
  492.     alloc_fmt[len++] = 'n';
  493.     alloc_fmt[len] = '';
  494.     TRACE (printf ("  scan "%s"n", alloc_fmt);
  495.    if (funs->scan == (gmp_doscan_scan_t) sscanf)
  496.      printf (" s="%s"n", * (const char **) data));
  497.     new_chars = -1;
  498.     if (param.ignore)
  499.       {
  500. new_fields = (*funs->scan) (data, alloc_fmt, &new_chars, NULL);
  501. ASSERT (new_fields == 0 || new_fields == EOF);
  502.       }
  503.     else
  504.       {
  505. void *arg = va_arg (ap, void *);
  506. new_fields = (*funs->scan) (data, alloc_fmt, arg, &new_chars);
  507. ASSERT (new_fields==0 || new_fields==1 || new_fields==EOF);
  508. if (new_fields == 0)
  509.   goto done;  /* invalid input */
  510. if (new_fields == 1)
  511.   ASSERT (new_chars != -1);
  512.       }
  513.     TRACE (printf ("  new_fields %d   new_chars %dn",
  514.    new_fields, new_chars));
  515.     if (new_fields == -1)
  516.       goto eof_no_match;  /* EOF before anything matched */
  517.     /* Under param.ignore, when new_fields==0 we don't know if
  518.        it's a successful match or an invalid field.  new_chars
  519.        won't have been assigned if it was an invalid field.  */
  520.     if (new_chars == -1)
  521.       goto done;  /* invalid input */
  522.     chars += new_chars;
  523.     (*funs->step) (data, new_chars);
  524.   increment_fields:
  525.     if (! param.ignore)
  526.       fields++;
  527.     goto next;
  528.   case 'd':   /* decimal */
  529.   case 'u':   /* decimal */
  530.     param.base = 10;
  531.     goto numeric;
  532.   case 'e':   /* float */
  533.   case 'E':   /* float */
  534.   case 'f':   /* float */
  535.   case 'g':   /* float */
  536.   case 'G':   /* float */
  537.   case 'i':   /* integer with base marker */
  538.   numeric:
  539.     if (param.type != 'F' && param.type != 'Q' && param.type != 'Z')
  540.       goto libc_type;
  541.     chars += skip_white (funs, data);
  542.     new_chars = gmpscan (funs, data, &param,
  543.  param.ignore ? NULL : va_arg (ap, void*));
  544.     if (new_chars == -2)
  545.       goto eof_no_match;
  546.     if (new_chars == -1)
  547.       goto done;
  548.     ASSERT (new_chars >= 0);
  549.     chars += new_chars;
  550.     goto increment_fields;
  551.   case 'a':   /* glibc allocate string */
  552.   case ''':  /* glibc digit groupings */
  553.     break;
  554.   case 'F':   /* mpf_t */
  555.   case 'j':   /* intmax_t */
  556.   case 'L':   /* long long */
  557.   case 'q':   /* quad_t */
  558.   case 'Q':   /* mpq_t */
  559.   case 't':   /* ptrdiff_t */
  560.   case 'z':   /* size_t */
  561.   case 'Z':   /* mpz_t */
  562.   set_type:
  563.     param.type = fchar;
  564.     break;
  565.   case 'h':   /* short or char */
  566.     if (param.type != 'h')
  567.       goto set_type;
  568.     param.type = 'H'; /* internal code for "hh" */
  569.     break;
  570.     goto numeric;
  571.   case 'l':   /* long, long long, double or long double */
  572.     if (param.type != 'l')
  573.       goto set_type;
  574.     param.type = 'L'; /* "ll" means "L" */
  575.     break;
  576.   case 'n':
  577.     if (! param.ignore)
  578.       {
  579. void  *p;
  580. p = va_arg (ap, void *);
  581. TRACE (printf ("  store %%n to %pn", p));
  582. switch (param.type) {
  583. case '': * (int *) p = chars; break;
  584. case 'F':  mpf_set_si ((mpf_ptr) p, (long) chars); break;
  585. case 'H':  * (char *) p = chars; break;
  586. case 'h':  * (short *) p = chars; break;
  587. #if HAVE_INTMAX_T
  588. case 'j':  * (intmax_t *) p = chars; break;
  589. #else
  590. case 'j':  ASSERT_FAIL (intmax_t not available); break;
  591. #endif
  592. case 'l':  * (long *) p = chars; break;
  593. #if HAVE_QUAD_T && HAVE_LONG_LONG
  594. case 'q':
  595.   ASSERT_ALWAYS (sizeof (quad_t) == sizeof (long long));
  596.   /*FALLTHRU*/
  597. #else
  598. case 'q':  ASSERT_FAIL (quad_t not available); break;
  599. #endif
  600. #if HAVE_LONG_LONG
  601. case 'L':  * (long long *) p = chars; break;
  602. #else
  603. case 'L':  ASSERT_FAIL (long long not available); break;
  604. #endif
  605. case 'Q':  mpq_set_si ((mpq_ptr) p, (long) chars, 1L); break;
  606. #if HAVE_PTRDIFF_T
  607. case 't':  * (ptrdiff_t *) p = chars; break;
  608. #else
  609. case 't':  ASSERT_FAIL (ptrdiff_t not available); break;
  610. #endif
  611. case 'z':  * (size_t *) p = chars; break;
  612. case 'Z':  mpz_set_si ((mpz_ptr) p, (long) chars); break;
  613. default: ASSERT (0); break;
  614. }
  615.       }
  616.     goto next;
  617.   case 'o':
  618.     param.base = 8;
  619.     goto numeric;
  620.   case 'x':
  621.   case 'X':
  622.     param.base = 16;
  623.     goto numeric;
  624.   case '0': case '1': case '2': case '3': case '4':
  625.   case '5': case '6': case '7': case '8': case '9':
  626.     param.width = 0;
  627.     do {
  628.       param.width = param.width * 10 + (fchar-'0');
  629.       fchar = *fmt++;
  630.     } while (isdigit (fchar));
  631.     fmt--; /* unget the non-digit */
  632.     break;
  633.   case '*':
  634.     param.ignore = 1;
  635.     break;
  636.   default:
  637.     /* something invalid in a % sequence */
  638.     ASSERT (0);
  639.     goto next;
  640.   }
  641. }
  642.     }
  643.  done:
  644.   (*__gmp_free_func) (alloc_fmt, alloc_fmt_size);
  645.   return fields;
  646. }