| 1 | 148 | jeremybenn | /*-
 | 
      
         | 2 |  |  |  * Copyright (c) 2002-2004 Tim J. Robbins.
 | 
      
         | 3 |  |  |  * All rights reserved.
 | 
      
         | 4 |  |  |  *
 | 
      
         | 5 |  |  |  * Redistribution and use in source and binary forms, with or without
 | 
      
         | 6 |  |  |  * modification, are permitted provided that the following conditions
 | 
      
         | 7 |  |  |  * are met:
 | 
      
         | 8 |  |  |  * 1. Redistributions of source code must retain the above copyright
 | 
      
         | 9 |  |  |  *    notice, this list of conditions and the following disclaimer.
 | 
      
         | 10 |  |  |  * 2. Redistributions in binary form must reproduce the above copyright
 | 
      
         | 11 |  |  |  *    notice, this list of conditions and the following disclaimer in the
 | 
      
         | 12 |  |  |  *    documentation and/or other materials provided with the distribution.
 | 
      
         | 13 |  |  |  *
 | 
      
         | 14 |  |  |  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 | 
      
         | 15 |  |  |  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 | 
      
         | 16 |  |  |  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 | 
      
         | 17 |  |  |  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 | 
      
         | 18 |  |  |  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 | 
      
         | 19 |  |  |  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 | 
      
         | 20 |  |  |  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 | 
      
         | 21 |  |  |  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 | 
      
         | 22 |  |  |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 | 
      
         | 23 |  |  |  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 | 
      
         | 24 |  |  |  * SUCH DAMAGE.
 | 
      
         | 25 |  |  |  */
 | 
      
         | 26 |  |  |  
 | 
      
         | 27 |  |  | /*
 | 
      
         | 28 |  |  | FUNCTION
 | 
      
         | 29 |  |  | <<ungetwc>>---push wide character data back into a stream
 | 
      
         | 30 |  |  |  
 | 
      
         | 31 |  |  | INDEX
 | 
      
         | 32 |  |  |         ungetwc
 | 
      
         | 33 |  |  | INDEX
 | 
      
         | 34 |  |  |         _ungetwc_r
 | 
      
         | 35 |  |  |  
 | 
      
         | 36 |  |  | ANSI_SYNOPSIS
 | 
      
         | 37 |  |  |         #include <stdio.h>
 | 
      
         | 38 |  |  |         #include <wchar.h>
 | 
      
         | 39 |  |  |         wint_t ungetwc(wint_t <[wc]>, FILE *<[stream]>);
 | 
      
         | 40 |  |  |  
 | 
      
         | 41 |  |  |         wint_t _ungetwc_r(struct _reent *<[reent]>, wint_t <[wc]>, FILE *<[stream]>);
 | 
      
         | 42 |  |  |  
 | 
      
         | 43 |  |  | DESCRIPTION
 | 
      
         | 44 |  |  | <<ungetwc>> is used to return wide characters back to <[stream]> to be
 | 
      
         | 45 |  |  | read again.  If <[wc]> is WEOF, the stream is unchanged.  Otherwise, the
 | 
      
         | 46 |  |  | wide character <[wc]> is put back on the stream, and subsequent reads will see
 | 
      
         | 47 |  |  | the wide chars pushed back in reverse order.  Pushed wide chars are lost if the
 | 
      
         | 48 |  |  | stream is repositioned, such as by <<fseek>>, <<fsetpos>>, or
 | 
      
         | 49 |  |  | <<rewind>>.
 | 
      
         | 50 |  |  |  
 | 
      
         | 51 |  |  | The underlying file is not changed, but it is possible to push back
 | 
      
         | 52 |  |  | something different than what was originally read.  Ungetting a
 | 
      
         | 53 |  |  | character will clear the end-of-stream marker, and decrement the file
 | 
      
         | 54 |  |  | position indicator.  Pushing back beyond the beginning of a file gives
 | 
      
         | 55 |  |  | unspecified behavior.
 | 
      
         | 56 |  |  |  
 | 
      
         | 57 |  |  | The alternate function <<_ungetwc_r>> is a reentrant version.  The
 | 
      
         | 58 |  |  | extra argument <[reent]> is a pointer to a reentrancy structure.
 | 
      
         | 59 |  |  |  
 | 
      
         | 60 |  |  | RETURNS
 | 
      
         | 61 |  |  | The wide character pushed back, or <<WEOF>> on error.
 | 
      
         | 62 |  |  |  
 | 
      
         | 63 |  |  | PORTABILITY
 | 
      
         | 64 |  |  | C99
 | 
      
         | 65 |  |  | */
 | 
      
         | 66 |  |  |  
 | 
      
         | 67 |  |  | #include <_ansi.h>
 | 
      
         | 68 |  |  | #include <reent.h>
 | 
      
         | 69 |  |  | #include <errno.h>
 | 
      
         | 70 |  |  | #include <limits.h>
 | 
      
         | 71 |  |  | #include <stdio.h>
 | 
      
         | 72 |  |  | #include <stdlib.h>
 | 
      
         | 73 |  |  | #include <wchar.h>
 | 
      
         | 74 |  |  | #include "local.h"
 | 
      
         | 75 |  |  |  
 | 
      
         | 76 |  |  | wint_t
 | 
      
         | 77 |  |  | _DEFUN(_ungetwc_r, (ptr, wc, fp),
 | 
      
         | 78 |  |  |         struct _reent *ptr _AND
 | 
      
         | 79 |  |  |         wint_t wc _AND
 | 
      
         | 80 |  |  |         register FILE *fp)
 | 
      
         | 81 |  |  | {
 | 
      
         | 82 |  |  |   char buf[MB_LEN_MAX];
 | 
      
         | 83 |  |  |   size_t len;
 | 
      
         | 84 |  |  |  
 | 
      
         | 85 |  |  |   _flockfile (fp);
 | 
      
         | 86 |  |  |   ORIENT (fp, 1);
 | 
      
         | 87 |  |  |   if (wc == WEOF)
 | 
      
         | 88 |  |  |     wc = WEOF;
 | 
      
         | 89 |  |  |   else if ((len = _wcrtomb_r(ptr, buf, wc, &fp->_mbstate)) == (size_t)-1)
 | 
      
         | 90 |  |  |     {
 | 
      
         | 91 |  |  |       fp->_flags |= __SERR;
 | 
      
         | 92 |  |  |       wc = WEOF;
 | 
      
         | 93 |  |  |     }
 | 
      
         | 94 |  |  |   else
 | 
      
         | 95 |  |  |     while (len-- != 0)
 | 
      
         | 96 |  |  |       if (_ungetc_r(ptr, (unsigned char)buf[len], fp) == EOF)
 | 
      
         | 97 |  |  |         {
 | 
      
         | 98 |  |  |           wc = WEOF;
 | 
      
         | 99 |  |  |           break;
 | 
      
         | 100 |  |  |         }
 | 
      
         | 101 |  |  |   _funlockfile (fp);
 | 
      
         | 102 |  |  |   return wc;
 | 
      
         | 103 |  |  | }
 | 
      
         | 104 |  |  |  
 | 
      
         | 105 |  |  | /*
 | 
      
         | 106 |  |  |  * MT-safe version.
 | 
      
         | 107 |  |  |  */
 | 
      
         | 108 |  |  | wint_t
 | 
      
         | 109 |  |  | _DEFUN(ungetwc, (wint_t wc, FILE *fp),
 | 
      
         | 110 |  |  |         wint_t wc _AND
 | 
      
         | 111 |  |  |         FILE *fp)
 | 
      
         | 112 |  |  | {
 | 
      
         | 113 |  |  |   CHECK_INIT (_REENT, fp);
 | 
      
         | 114 |  |  |   return _ungetwc_r (_REENT, wc, fp);
 | 
      
         | 115 |  |  | }
 |