lib/libc/stdio/ungetc.c

   1 /*-
   2  * Copyright (c) 1990, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * This code is derived from software contributed to Berkeley by
   6  * Chris Torek.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the name of the University nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  *
  32  * @(#)ungetc.c 8.2 (Berkeley) 11/3/93
  33  * $FreeBSD: src/lib/libc/stdio/ungetc.c,v 1.18 2008/04/17 22:17:54 jhb Exp $
  34  * $DragonFly: src/lib/libc/stdio/ungetc.c,v 1.8 2005/11/20 11:07:30 swildner Exp $
  35  */
  36
  37 #include "namespace.h"
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41 #include "un-namespace.h"
  42 #include "local.h"
  43 #include "libc_private.h"
  44 #include "priv_stdio.h"
  45
  46 static int __submore(FILE *);
  47
  48 /*
  49  * Expand the ungetc buffer `in place'.  That is, adjust fp->pub._p when
  50  * the buffer moves, so that it points the same distance from the end,
  51  * and move the bytes in the buffer around as necessary so that they
  52  * are all at the end (stack-style).
  53  */
  54 static int
  55 __submore(FILE *fp)
  56 {
  57         int i;
  58         unsigned char *p;
  59
  60         if (fp->_ub._base == fp->_ubuf) {
  61                 /*
  62                  * Get a new buffer (rather than expanding the old one).
  63                  */
  64                 if ((p = malloc((size_t)BUFSIZ)) == NULL)
  65                         return (EOF);
  66                 fp->_ub._base = p;
  67                 fp->_ub._size = BUFSIZ;
  68                 p += BUFSIZ - sizeof(fp->_ubuf);
  69                 for (i = sizeof(fp->_ubuf); --i >= 0;)
  70                         p[i] = fp->_ubuf[i];
  71                 fp->pub._p = p;
  72                 return (0);
  73         }
  74         i = fp->_ub._size;
  75         p = realloc(fp->_ub._base, (size_t)(i << 1));
  76         if (p == NULL)
  77                 return (EOF);
  78         /* no overlap (hence can use memcpy) because we doubled the size */
  79         memcpy((void *)(p + i), (void *)p, (size_t)i);
  80         fp->pub._p = p + i;
  81         fp->_ub._base = p;
  82         fp->_ub._size = i << 1;
  83         return (0);
  84 }
  85
  86 /*
  87  * MT-safe version
  88  */
  89 int
  90 ungetc(int c, FILE *fp)
  91 {
  92         int ret;
  93
  94         if (!__sdidinit)
  95                 __sinit();
  96         FLOCKFILE(fp);
  97         ORIENT(fp, -1);
  98         ret = __ungetc(c, fp);
  99         FUNLOCKFILE(fp);
 100         return (ret);
 101 }
 102
 103 /*
 104  * Non-MT-safe version
 105  */
 106 int
 107 __ungetc(int c, FILE *fp)
 108 {
 109         if (c == EOF)
 110                 return (EOF);
 111         if ((fp->pub._flags & __SRD) == 0) {
 112                 /*
 113                  * Not already reading: no good unless reading-and-writing.
 114                  * Otherwise, flush any current write stuff.
 115                  */
 116                 if ((fp->pub._flags & __SRW) == 0)
 117                         return (EOF);
 118                 if (fp->pub._flags & __SWR) {
 119                         if (__sflush(fp))
 120                                 return (EOF);
 121                         fp->pub._flags &= ~__SWR;
 122                         fp->pub._w = 0;
 123                         fp->pub._lbfsize = 0;
 124                 }
 125                 fp->pub._flags |= __SRD;
 126         }
 127         c = (unsigned char)c;
 128
 129         /*
 130          * If we are in the middle of ungetc'ing, just continue.
 131          * This may require expanding the current ungetc buffer.
 132          */
 133         if (HASUB(fp)) {
 134                 if (fp->pub._r >= fp->_ub._size && __submore(fp))
 135                         return (EOF);
 136                 *--fp->pub._p = c;
 137                 fp->pub._r++;
 138                 return (c);
 139         }
 140         fp->pub._flags &= ~__SEOF;
 141
 142         /*
 143          * If we can handle this by simply backing up, do so,
 144          * but never replace the original character.
 145          * (This makes sscanf() work when scanning `const' data.)
 146          */
 147         if (fp->_bf._base != NULL && fp->pub._p > fp->_bf._base &&
 148             fp->pub._p[-1] == c) {
 149                 fp->pub._p--;
 150                 fp->pub._r++;
 151                 return (c);
 152         }
 153
 154         /*
 155          * Create an ungetc buffer.
 156          * Initially, we will use the `reserve' buffer.
 157          */
 158         fp->_ur = fp->pub._r;
 159         fp->_up = fp->pub._p;
 160         fp->_ub._base = fp->_ubuf;
 161         fp->_ub._size = sizeof(fp->_ubuf);
 162         fp->_ubuf[sizeof(fp->_ubuf) - 1] = c;
 163         fp->pub._p = &fp->_ubuf[sizeof(fp->_ubuf) - 1];
 164         fp->pub._r = 1;
 165         return (c);
 166 }