home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / libg++-2.7.1-base.tgz / libg++-2.7.1-src.tar / fsf / libg++ / libio / genops.c < prev    next >
C/C++ Source or Header  |  1995-06-15  |  20KB  |  838 lines
  1. /* 
  2. Copyright (C) 1993, 1995 Free Software Foundation
  3.  
  4. This file is part of the GNU IO Library.  This library is free
  5. software; you can redistribute it and/or modify it under the
  6. terms of the GNU General Public License as published by the
  7. Free Software Foundation; either version 2, or (at your option)
  8. any later version.
  9.  
  10. This library is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. GNU General Public License for more details.
  14.  
  15. You should have received a copy of the GNU General Public License
  16. along with this library; see the file COPYING.  If not, write to the Free
  17. Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18.  
  19. As a special exception, if you link this library with files
  20. compiled with a GNU compiler to produce an executable, this does not cause
  21. the resulting executable to be covered by the GNU General Public License.
  22. This exception does not however invalidate any other reasons why
  23. the executable file might be covered by the GNU General Public License. */
  24.  
  25. /* Generic or default I/O operations. */
  26.  
  27. #include "libioP.h"
  28. #ifdef __STDC__
  29. #include <stdlib.h>
  30. #endif
  31. #include <string.h>
  32.  
  33. void
  34. DEFUN(_IO_un_link, (fp),
  35.       _IO_FILE *fp)
  36. {
  37.   if (fp->_flags & _IO_LINKED) {
  38.     _IO_FILE **f;
  39.     for (f = &_IO_list_all; *f != NULL; f = &(*f)->_chain) {
  40.       if (*f == fp) {
  41.     *f = fp->_chain;
  42.     break;
  43.       }
  44.     }
  45.     fp->_flags &= ~_IO_LINKED;
  46.   }
  47. }
  48.  
  49. void
  50. DEFUN(_IO_link_in, (fp),
  51.       _IO_FILE *fp)
  52. {
  53.     if ((fp->_flags & _IO_LINKED) == 0) {
  54.     fp->_flags |= _IO_LINKED;
  55.     fp->_chain = _IO_list_all;
  56.     _IO_list_all = fp;
  57.     }
  58. }
  59.  
  60. /* Return minimum _pos markers
  61.    Assumes the current get area is the main get area. */
  62.  
  63. _IO_size_t
  64. DEFUN(_IO_least_marker, (fp),
  65.       register _IO_FILE *fp)
  66. {
  67.   _IO_ssize_t least_so_far = fp->_IO_read_end - fp->_IO_read_base;
  68.   register struct _IO_marker *mark;
  69.   for (mark = fp->_markers; mark != NULL; mark = mark->_next)
  70.     if (mark->_pos < least_so_far)
  71.       least_so_far = mark->_pos;
  72.   return least_so_far;
  73. }
  74.  
  75. /* Switch current get area from backup buffer to (start of) main get area. */
  76.  
  77. void
  78. DEFUN(_IO_switch_to_main_get_area, (fp),
  79.       _IO_FILE *fp)
  80. {
  81.   char *tmp;
  82.   fp->_flags &= ~_IO_IN_BACKUP;
  83.   /* Swap _IO_read_end and _IO_save_end. */
  84.   tmp = fp->_IO_read_end; fp->_IO_read_end= fp->_IO_save_end; fp->_IO_save_end= tmp;
  85.   /* Swap _IO_read_base and _IO_save_base. */
  86.   tmp = fp->_IO_read_base; fp->_IO_read_base = fp->_IO_save_base; fp->_IO_save_base = tmp;
  87.   fp->_IO_read_ptr = fp->_IO_read_base;
  88. }
  89.  
  90. /* Switch current get area from main get area to (end of) backup area. */
  91.  
  92. void
  93. DEFUN(_IO_switch_to_backup_area, (fp),
  94.      register _IO_FILE *fp)
  95. {
  96.   char *tmp;
  97.   fp->_flags |= _IO_IN_BACKUP;
  98.   /* Swap _IO_read_end and _IO_save_end. */
  99.   tmp = fp->_IO_read_end; fp->_IO_read_end = fp->_IO_save_end; fp->_IO_save_end = tmp;
  100.   /* Swap _gbase and _IO_save_base. */
  101.   tmp = fp->_IO_read_base; fp->_IO_read_base = fp->_IO_save_base; fp->_IO_save_base = tmp;
  102.   fp->_IO_read_ptr = fp->_IO_read_end;
  103. }
  104.  
  105. int
  106. DEFUN(_IO_switch_to_get_mode, (fp),
  107.      register _IO_FILE *fp)
  108. {
  109.   if (fp->_IO_write_ptr > fp->_IO_write_base)
  110.     if (_IO_OVERFLOW (fp, EOF) == EOF)
  111.       return EOF;
  112.   if (_IO_in_backup(fp))
  113.     fp->_IO_read_base = fp->_IO_backup_base;
  114.   else
  115.     {
  116.       fp->_IO_read_base = fp->_IO_buf_base;
  117.       if (fp->_IO_write_ptr > fp->_IO_read_end)
  118.     fp->_IO_read_end = fp->_IO_write_ptr;
  119.     }
  120.   fp->_IO_read_ptr = fp->_IO_write_ptr;
  121.  
  122.   fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end = fp->_IO_read_ptr;
  123.  
  124.   fp->_flags &= ~_IO_CURRENTLY_PUTTING;
  125.   return 0;
  126. }
  127.  
  128. void
  129. DEFUN(_IO_free_backup_area, (fp),
  130.      register _IO_FILE *fp)
  131. {
  132.   if (_IO_in_backup (fp))
  133.     _IO_switch_to_main_get_area(fp);  /* Just in case. */
  134.   free (fp->_IO_save_base);
  135.   fp->_IO_save_base = NULL;
  136.   fp->_IO_save_end = NULL;
  137.   fp->_IO_backup_base = NULL;
  138. }
  139.  
  140. #if 0
  141. int
  142. DEFUN(_IO_switch_to_put_mode, (fp),
  143.       register _IO_FILE *fp)
  144. {
  145.   fp->_IO_write_base = fp->_IO_read_ptr;
  146.   fp->_IO_write_ptr = fp->_IO_read_ptr;
  147.   /* Following is wrong if line- or un-buffered? */
  148.   fp->_IO_write_end = fp->_flags & _IO_IN_BACKUP ? fp->_IO_read_end : fp->_IO_buf_end;
  149.  
  150.   fp->_IO_read_ptr = fp->_IO_read_end;
  151.   fp->_IO_read_base = fp->_IO_read_end;
  152.  
  153.   fp->_flags |= _IO_CURRENTLY_PUTTING;
  154.   return 0;
  155. }
  156. #endif
  157.  
  158. int
  159. DEFUN(__overflow, (f, ch),
  160.       _IO_FILE *f AND int ch)
  161. {
  162.   return _IO_OVERFLOW (f, ch);
  163. }
  164.  
  165. static int
  166. DEFUN(save_for_backup, (fp),
  167.       _IO_FILE *fp)
  168. {
  169.   /* Append [_IO_read_base.._IO_read_end] to backup area. */
  170.   int least_mark = _IO_least_marker(fp);
  171.   /* needed_size is how much space we need in the backup area. */
  172.   int needed_size = (fp->_IO_read_end - fp->_IO_read_base) - least_mark;
  173.   int current_Bsize = fp->_IO_save_end - fp->_IO_save_base;
  174.   int avail; /* Extra space available for future expansion. */
  175.   int delta;
  176.   struct _IO_marker *mark;
  177.   if (needed_size > current_Bsize)
  178.     {
  179.       char *new_buffer;
  180.       avail = 100;
  181.       new_buffer = (char*)malloc(avail+needed_size);
  182.       if (new_buffer == NULL)
  183.     return EOF;        /* FIXME */
  184.       if (least_mark < 0)
  185.     {
  186.       memcpy(new_buffer + avail,
  187.          fp->_IO_save_end + least_mark,
  188.          -least_mark);
  189.       memcpy(new_buffer +avail - least_mark,
  190.          fp->_IO_read_base,
  191.          fp->_IO_read_end - fp->_IO_read_base);
  192.     }
  193.       else
  194.     memcpy(new_buffer + avail,
  195.            fp->_IO_read_base + least_mark,
  196.            needed_size);
  197.       if (fp->_IO_save_base)
  198.     free (fp->_IO_save_base);
  199.       fp->_IO_save_base = new_buffer;
  200.       fp->_IO_save_end = new_buffer + avail + needed_size;
  201.     }
  202.   else
  203.     {
  204.       avail = current_Bsize - needed_size;
  205.       if (least_mark < 0)
  206.     {
  207.       memmove(fp->_IO_save_base + avail,
  208.           fp->_IO_save_end + least_mark,
  209.           -least_mark);
  210.       memcpy(fp->_IO_save_base + avail - least_mark,
  211.          fp->_IO_read_base,
  212.          fp->_IO_read_end - fp->_IO_read_base);
  213.     }
  214.       else if (needed_size > 0)
  215.     memcpy(fp->_IO_save_base + avail,
  216.            fp->_IO_read_base + least_mark,
  217.            needed_size);
  218.     }
  219.   /* FIXME: Dubious arithmetic if pointers are NULL */
  220.   fp->_IO_backup_base = fp->_IO_save_base + avail;
  221.   /* Adjust all the streammarkers. */
  222.   delta = fp->_IO_read_end - fp->_IO_read_base;
  223.   for (mark = fp->_markers; mark != NULL; mark = mark->_next)
  224.     mark->_pos -= delta;
  225.   return 0;
  226. }
  227.  
  228. int
  229. DEFUN(__underflow, (fp),
  230.       _IO_FILE *fp)
  231. {
  232.   if (_IO_in_put_mode(fp))
  233.     if (_IO_switch_to_get_mode(fp) == EOF) return EOF;
  234.   if (fp->_IO_read_ptr < fp->_IO_read_end)
  235.     return *(unsigned char*)fp->_IO_read_ptr;
  236.   if (_IO_in_backup(fp))
  237.     {
  238.       _IO_switch_to_main_get_area(fp);
  239.       if (fp->_IO_read_ptr < fp->_IO_read_end)
  240.     return *fp->_IO_read_ptr;
  241.     }
  242.   if (_IO_have_markers(fp))
  243.     {
  244.       if (save_for_backup (fp))
  245.     return EOF;
  246.     }
  247.   else if (_IO_have_backup(fp))
  248.     _IO_free_backup_area(fp);
  249.   return _IO_UNDERFLOW (fp);
  250. }
  251.  
  252. int
  253. DEFUN(__uflow, (fp),
  254.      _IO_FILE *fp)
  255. {
  256.   if (_IO_in_put_mode(fp))
  257.     if (_IO_switch_to_get_mode(fp) == EOF) return EOF;
  258.   if (fp->_IO_read_ptr < fp->_IO_read_end)
  259.     return *(unsigned char*)fp->_IO_read_ptr++;
  260.   if (_IO_in_backup(fp))
  261.     {
  262.       _IO_switch_to_main_get_area(fp);
  263.       if (fp->_IO_read_ptr < fp->_IO_read_end)
  264.     return *fp->_IO_read_ptr++;
  265.     }
  266.   if (_IO_have_markers(fp))
  267.     {
  268.       if (save_for_backup (fp))
  269.     return EOF;
  270.     }
  271.   else if (_IO_have_backup(fp))
  272.     _IO_free_backup_area(fp);
  273.   return _IO_UFLOW (fp);
  274. }
  275.  
  276. void
  277. DEFUN(_IO_setb, (f, b, eb, a),
  278.       _IO_FILE *f AND char *b AND char *eb AND int a)
  279. {
  280.   if (f->_IO_buf_base && !(f->_flags & _IO_USER_BUF))
  281.     FREE_BUF(f->_IO_buf_base);
  282.   f->_IO_buf_base = b;
  283.   f->_IO_buf_end = eb;
  284.   if (a)
  285.     f->_flags &= ~_IO_USER_BUF;
  286.   else
  287.     f->_flags |= _IO_USER_BUF;
  288. }
  289.  
  290. void
  291. DEFUN(_IO_doallocbuf, (fp),
  292.       register _IO_FILE *fp)
  293. {
  294.   if (fp->_IO_buf_base)
  295.     return;
  296.   if (!(fp->_flags & _IO_UNBUFFERED))
  297.     if (_IO_DOALLOCATE (fp) != EOF)
  298.       return;
  299.   _IO_setb(fp, fp->_shortbuf, fp->_shortbuf+1, 0);
  300. }
  301.  
  302. int
  303. DEFUN(_IO_default_underflow, (fp),
  304.       _IO_FILE *fp)
  305. {
  306.   return EOF;
  307. }
  308.  
  309. int
  310. DEFUN(_IO_default_uflow, (fp),
  311.       _IO_FILE *fp)
  312. {
  313.   int ch = _IO_UNDERFLOW (fp);
  314.   if (ch == EOF)
  315.     return EOF;
  316.   return *(unsigned char*)fp->_IO_read_ptr++;
  317. }
  318.  
  319. _IO_size_t
  320. DEFUN(_IO_default_xsputn, (f, data, n),
  321.       register _IO_FILE *f AND const void *data AND _IO_size_t n)
  322. {
  323.   register const char *s = (char*) data;
  324.   register _IO_size_t more = n;
  325.   if (more <= 0)
  326.     return 0;
  327.   for (;;)
  328.     {
  329.       _IO_ssize_t count = f->_IO_write_end - f->_IO_write_ptr; /* Space available. */
  330.       if (count > 0)
  331.     {
  332.       if (count > more)
  333.         count = more;
  334.       if (count > 20)
  335.         {
  336.           memcpy(f->_IO_write_ptr, s, count);
  337.           s += count;
  338.           f->_IO_write_ptr += count;
  339.             }
  340.       else if (count <= 0)
  341.         count = 0;
  342.       else
  343.         {
  344.           register char *p = f->_IO_write_ptr;
  345.           register _IO_ssize_t i;
  346.           for (i = count; --i >= 0; ) *p++ = *s++;
  347.           f->_IO_write_ptr = p;
  348.             }
  349.       more -= count;
  350.         }
  351.       if (more == 0 || __overflow(f, (unsigned char)*s++) == EOF)
  352.     break;
  353.       more--;
  354.     }
  355.   return n - more;
  356. }
  357.  
  358. _IO_size_t
  359. DEFUN(_IO_sgetn, (fp, data, n),
  360.       _IO_FILE *fp AND void *data AND _IO_size_t n)
  361. {
  362.   /* FIXME handle putback buffer here! */
  363.   return _IO_XSGETN (fp, data, n);
  364. }
  365.  
  366. _IO_size_t
  367. DEFUN(_IO_default_xsgetn, (fp, data, n),
  368.       _IO_FILE *fp AND void *data AND _IO_size_t n)
  369. {
  370.   register _IO_size_t more = n;
  371.   register char *s = (char*) data;
  372.   for (;;)
  373.     {
  374.       _IO_ssize_t count = fp->_IO_read_end - fp->_IO_read_ptr; /* Data available. */
  375.       if (count > 0)
  376.     {
  377.       if (count > more)
  378.         count = more;
  379.       if (count > 20)
  380.         {
  381.           memcpy(s, fp->_IO_read_ptr, count);
  382.           s += count;
  383.           fp->_IO_read_ptr += count;
  384.         }
  385.       else if (count <= 0)
  386.         count = 0;
  387.       else
  388.         {
  389.           register char *p = fp->_IO_read_ptr;
  390.           register int i = (int)count;
  391.           while (--i >= 0) *s++ = *p++;
  392.           fp->_IO_read_ptr = p;
  393.             }
  394.             more -= count;
  395.         }
  396.       if (more == 0 || __underflow(fp) == EOF)
  397.     break;
  398.     }
  399.   return n - more;
  400. }
  401.  
  402. int
  403. DEFUN(_IO_sync, (fp),
  404.       register _IO_FILE *fp)
  405. {
  406.   return 0;
  407. }
  408.  
  409. _IO_FILE*
  410. DEFUN(_IO_default_setbuf, (fp, p, len),
  411.       register _IO_FILE *fp AND char* p AND _IO_ssize_t len)
  412. {
  413.     if (_IO_SYNC (fp) == EOF)
  414.     return NULL;
  415.     if (p == NULL || len == 0)
  416.       {
  417.     fp->_flags |= _IO_UNBUFFERED;
  418.     _IO_setb(fp, fp->_shortbuf, fp->_shortbuf+1, 0);
  419.       }
  420.     else
  421.       {
  422.     fp->_flags &= ~_IO_UNBUFFERED;
  423.     _IO_setb(fp, p, p+len, 0);
  424.       }
  425.     fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end = 0;
  426.     fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_read_end = 0;
  427.     return fp;
  428. }
  429.  
  430. _IO_pos_t
  431. DEFUN(_IO_default_seekpos, (fp, pos, mode),
  432.       _IO_FILE *fp AND _IO_pos_t pos AND int mode)
  433. {
  434.   return _IO_SEEKOFF (fp, _IO_pos_as_off(pos), 0, mode);
  435. }
  436.  
  437. int
  438. DEFUN(_IO_default_doallocate, (fp),
  439.       _IO_FILE *fp)
  440. {
  441.   char *buf = ALLOC_BUF(_IO_BUFSIZ);
  442.   if (buf == NULL)
  443.     return EOF;
  444.   _IO_setb(fp, buf, buf+_IO_BUFSIZ, 1);
  445.   return 1;
  446. }
  447.  
  448. void
  449. DEFUN(_IO_init, (fp, flags),
  450.       register _IO_FILE *fp AND int flags)
  451. {
  452.   fp->_flags = _IO_MAGIC|flags;
  453.   fp->_IO_buf_base = NULL;
  454.   fp->_IO_buf_end = NULL;
  455.   fp->_IO_read_base = NULL;
  456.   fp->_IO_read_ptr = NULL;
  457.   fp->_IO_read_end = NULL;
  458.   fp->_IO_write_base = NULL;
  459.   fp->_IO_write_ptr = NULL;
  460.   fp->_IO_write_end = NULL;
  461.   fp->_chain = NULL; /* Not necessary. */
  462.  
  463.   fp->_IO_save_base = NULL;
  464.   fp->_IO_backup_base = NULL;
  465.   fp->_IO_save_end = NULL;
  466.   fp->_markers = NULL;
  467.   fp->_cur_column = 0;
  468. }
  469.  
  470. int
  471. DEFUN(_IO_default_sync, (fp),
  472.       _IO_FILE *fp)
  473. {
  474.   return 0;
  475. }
  476.  
  477. /* The way the C++ classes are mapped into the C functions in the
  478.    current implementation, this function can get called twice! */
  479.  
  480. void
  481. DEFUN(_IO_default_finish, (fp),
  482.       _IO_FILE *fp)
  483. {
  484.   struct _IO_marker *mark;
  485.   if (fp->_IO_buf_base && !(fp->_flags & _IO_USER_BUF))
  486.     {
  487.       FREE_BUF(fp->_IO_buf_base);
  488.       fp->_IO_buf_base = fp->_IO_buf_end = NULL;
  489.     }
  490.  
  491.   for (mark = fp->_markers; mark != NULL; mark = mark->_next)
  492.     mark->_sbuf = NULL;
  493.  
  494.   if (fp->_IO_save_base)
  495.     {
  496.       free (fp->_IO_save_base);
  497.       fp->_IO_save_base = NULL;
  498.     }
  499.  
  500.   _IO_un_link(fp);
  501. }
  502.  
  503. _IO_pos_t
  504. DEFUN(_IO_default_seekoff, (fp, offset, dir, mode),
  505.       register _IO_FILE *fp AND _IO_off_t offset AND int dir AND int mode)
  506. {
  507.     return _IO_pos_BAD;
  508. }
  509.  
  510. int
  511. DEFUN(_IO_sputbackc, (fp, c),
  512.       register _IO_FILE *fp AND int c)
  513. {
  514.   if (fp->_IO_read_ptr > fp->_IO_read_base
  515.       && (unsigned char)fp->_IO_read_ptr[-1] == (unsigned char)c)
  516.     {
  517.       fp->_IO_read_ptr--;
  518.       return (unsigned char)c;
  519.     }
  520.   return _IO_PBACKFAIL (fp, c);
  521. }
  522.  
  523. int
  524. DEFUN(_IO_sungetc, (fp),
  525.       register _IO_FILE *fp)
  526. {
  527.   if (fp->_IO_read_ptr > fp->_IO_read_base)
  528.     {
  529.       fp->_IO_read_ptr--;
  530.       return (unsigned char)*fp->_IO_read_ptr;
  531.     }
  532.   else
  533.     return _IO_PBACKFAIL (fp, EOF);
  534. }
  535.  
  536. #if 0 /* Work in progress */
  537. void
  538. DEFUN(_IO_set_column, (fp, c),
  539.       register _IO_FILE *fp AND int c)
  540. {
  541.   if (c == -1)
  542.     fp->_column = -1;
  543.   else
  544.     fp->_column = c - (fp->_IO_write_ptr - fp->_IO_write_base);
  545. }
  546. #else
  547. int
  548. DEFUN(_IO_set_column, (fp, i),
  549.       register _IO_FILE *fp AND int i)
  550. {
  551.   fp->_cur_column = i+1;
  552.   return 0;
  553. }
  554. #endif
  555.  
  556.  
  557. unsigned
  558. DEFUN(_IO_adjust_column, (start, line, count),
  559.       unsigned start AND const char *line AND int count)
  560. {
  561.   register const char *ptr = line + count;
  562.   while (ptr > line)
  563.     if (*--ptr == '\n')
  564.       return line + count - ptr - 1;
  565.   return start + count;
  566. }
  567.  
  568. int
  569. DEFUN(_IO_get_column, (fp),
  570.       register _IO_FILE *fp)
  571. {
  572.   if (fp->_cur_column) 
  573.     return _IO_adjust_column(fp->_cur_column - 1,
  574.                   fp->_IO_write_base,
  575.                   fp->_IO_write_ptr - fp->_IO_write_base);
  576.   return -1;
  577. }
  578.  
  579. int
  580. DEFUN_VOID(_IO_flush_all)
  581. {
  582.   int result = 0;
  583.   _IO_FILE *fp;
  584.   for (fp = _IO_list_all; fp != NULL; fp = fp->_chain)
  585.     if (fp->_IO_write_ptr > fp->_IO_write_base
  586.     && _IO_OVERFLOW (fp, EOF) == EOF)
  587.       result = EOF;
  588.   return result;
  589. }
  590.  
  591. void
  592. DEFUN_VOID(_IO_flush_all_linebuffered)
  593. {
  594.   _IO_FILE *fp;
  595.   for (fp = _IO_list_all; fp != NULL; fp = fp->_chain)
  596.     if (fp->_flags & _IO_LINE_BUF)
  597.       _IO_OVERFLOW (fp, EOF);
  598. }
  599.  
  600. void
  601. DEFUN_VOID(_IO_unbuffer_all)
  602. {
  603.   _IO_FILE *fp;
  604.   for (fp = _IO_list_all; fp != NULL; fp = fp->_chain)
  605.     if (! (fp->_flags & _IO_UNBUFFERED))
  606.       _IO_SETBUF (fp, NULL, 0);
  607. }
  608.  
  609. void
  610. DEFUN_VOID(_IO_cleanup)
  611. {
  612.   _IO_flush_all ();
  613.  
  614.   /* We currently don't have a reliable mechanism for making sure that
  615.      C++ static destructors are executed in the correct order.
  616.      So it is possible that other static destructord might want to
  617.      write to cout - and they're supposed to be able to do so.
  618.  
  619.      The following will make the standard streambufs be unbuffered, 
  620.      which forces any output from late destructors to be written out. */
  621.   _IO_unbuffer_all ();
  622. }
  623.  
  624. void
  625. DEFUN(_IO_init_marker, (marker, fp),
  626.       struct _IO_marker *marker AND _IO_FILE *fp)
  627. {
  628.   marker->_sbuf = fp;
  629.   if (_IO_in_put_mode(fp))
  630.     _IO_switch_to_get_mode(fp);
  631.   if (_IO_in_backup(fp))
  632.     marker->_pos = fp->_IO_read_ptr - fp->_IO_read_end;
  633.   else
  634.     marker->_pos = fp->_IO_read_ptr - fp->_IO_read_base;
  635.   
  636.   /* Should perhaps sort the chain? */
  637.   marker->_next = fp->_markers;
  638.   fp->_markers = marker;
  639. }
  640.  
  641. void
  642. DEFUN(_IO_remove_marker, (marker),
  643.       register struct _IO_marker *marker)
  644. {
  645.   /* Unlink from sb's chain. */
  646.   register struct _IO_marker **ptr = &marker->_sbuf->_markers;
  647.   for (; ; ptr = &(*ptr)->_next)
  648.     {
  649.       if (*ptr == NULL)
  650.     break;
  651.       else if (*ptr == marker)
  652.     {
  653.       *ptr = marker->_next;
  654.       return;
  655.     }
  656.     }
  657. #if 0
  658.     if _sbuf has a backup area that is no longer needed, should we delete
  659.     it now, or wait until the next underflow?
  660. #endif
  661. }
  662.  
  663. #define BAD_DELTA EOF
  664.  
  665. int
  666. DEFUN(_IO_marker_difference, (mark1, mark2),
  667.       struct _IO_marker *mark1 AND struct _IO_marker *mark2)
  668. {
  669.   return mark1->_pos - mark2->_pos;
  670. }
  671.  
  672. /* Return difference between MARK and current posistion of MARK's stream. */
  673. int
  674. DEFUN(_IO_marker_delta, (mark),
  675.       struct _IO_marker *mark)
  676. {
  677.   int cur_pos;
  678.   if (mark->_sbuf == NULL)
  679.     return BAD_DELTA;
  680.   if (_IO_in_backup(mark->_sbuf))
  681.     cur_pos = mark->_sbuf->_IO_read_ptr - mark->_sbuf->_IO_read_end;
  682.   else
  683.     cur_pos = mark->_sbuf->_IO_read_ptr - mark->_sbuf->_IO_read_base;
  684.   return mark->_pos - cur_pos;
  685. }
  686.  
  687. int
  688. DEFUN(_IO_seekmark, (fp, mark, delta),
  689.       _IO_FILE *fp AND struct _IO_marker *mark AND int delta)
  690. {
  691.   if (mark->_sbuf != fp)
  692.     return EOF;
  693.  if (mark->_pos >= 0)
  694.     {
  695.       if (_IO_in_backup(fp))
  696.     _IO_switch_to_main_get_area(fp);
  697.       fp->_IO_read_ptr = fp->_IO_read_base + mark->_pos;
  698.     }
  699.   else
  700.     {
  701.       if (!_IO_in_backup(fp))
  702.     _IO_switch_to_backup_area(fp);
  703.       fp->_IO_read_ptr = fp->_IO_read_end + mark->_pos;
  704.     }
  705.   return 0;
  706. }
  707.  
  708. void
  709. DEFUN(_IO_unsave_markers, (fp),
  710.      register _IO_FILE *fp)
  711. {
  712.   register struct _IO_marker *mark = fp->_markers;
  713.   if (mark)
  714.     {
  715. #ifdef TODO
  716.       streampos offset = seekoff(0, ios::cur, ios::in);
  717.       if (offset != EOF)
  718.     {
  719.       offset += eGptr() - Gbase();
  720.       for ( ; mark != NULL; mark = mark->_next)
  721.         mark->set_streampos(mark->_pos + offset);
  722.     }
  723.     else
  724.       {
  725.     for ( ; mark != NULL; mark = mark->_next)
  726.       mark->set_streampos(EOF);
  727.       }
  728. #endif
  729.       fp->_markers = 0;
  730.     }
  731.  
  732.   if (_IO_have_backup(fp))
  733.     _IO_free_backup_area(fp);
  734. }
  735.  
  736. int
  737. DEFUN(_IO_nobackup_pbackfail, (fp, c),
  738.      register _IO_FILE *fp AND int c)
  739. {
  740.   if (fp->_IO_read_ptr > fp->_IO_read_base)
  741.     fp->_IO_read_ptr--;
  742.   if (c != EOF && *fp->_IO_read_ptr != c)
  743.       *fp->_IO_read_ptr = c;
  744.   return (unsigned char)c;
  745. }
  746.  
  747. int
  748. DEFUN(_IO_default_pbackfail, (fp, c),
  749.       register _IO_FILE *fp AND int c)
  750. {
  751.   if (fp->_IO_read_ptr <= fp->_IO_read_base)
  752.       {
  753.     /* Need to handle a filebuf in write mode (switch to read mode). FIXME!*/
  754.     if (_IO_have_backup(fp) && !_IO_in_backup(fp))
  755.       _IO_switch_to_backup_area(fp);
  756.     
  757.     if (!_IO_have_backup(fp))
  758.       {
  759.         /* No backup buffer: allocate one. */
  760.         /* Use nshort buffer, if unused? (probably not)  FIXME */
  761.         int backup_size = 128;
  762.         char *bbuf = (char*)malloc(backup_size);
  763.         if (bbuf == NULL)
  764.           return EOF;
  765.         fp->_IO_save_base = bbuf;
  766.         fp->_IO_save_end = fp->_IO_save_base + backup_size;
  767.         fp->_IO_backup_base = fp->_IO_save_end;
  768.         _IO_switch_to_backup_area(fp);
  769.       }
  770.     else if (fp->_IO_read_ptr <= fp->_IO_read_base)
  771.       {
  772.         /* Increase size of existing backup buffer. */
  773.         _IO_size_t new_size;
  774.         _IO_size_t old_size = fp->_IO_read_end - fp->_IO_read_base;
  775.         char *new_buf;
  776.         new_size = 2 * old_size;
  777.         new_buf = (char*)malloc(new_size);
  778.         if (new_buf == NULL)
  779.           return EOF;
  780.         memcpy(new_buf+(new_size-old_size), fp->_IO_read_base, old_size);
  781.         free (fp->_IO_read_base);
  782.         _IO_setg(fp,
  783.              new_buf, new_buf+(new_size-old_size), new_buf+new_size);
  784.         fp->_IO_backup_base = fp->_IO_read_ptr;
  785.       }
  786.       }
  787.   fp->_IO_read_ptr--;
  788.   if (c != EOF && *fp->_IO_read_ptr != c)
  789.     *fp->_IO_read_ptr = c;
  790.   return (unsigned char)*fp->_IO_read_ptr;
  791. }
  792.  
  793. _IO_pos_t
  794. DEFUN(_IO_default_seek, (fp, offset, dir),
  795.       _IO_FILE *fp AND _IO_off_t offset AND int dir)
  796. {
  797.   return _IO_pos_BAD;
  798. }
  799.  
  800. int
  801. DEFUN(_IO_default_stat, (fp, st),
  802.       _IO_FILE *fp AND void* st)
  803. {
  804.   return EOF;
  805. }
  806.  
  807. _IO_ssize_t
  808. DEFUN(_IO_default_read, (fp, data, n),
  809.       register _IO_FILE* fp AND void* data AND _IO_ssize_t n)
  810. {
  811.   return -1;
  812. }
  813.  
  814. _IO_ssize_t
  815. DEFUN(_IO_default_write, (fp, data, n),
  816.       register _IO_FILE* fp AND const void* data AND _IO_ssize_t n)
  817. {
  818.   return 0;
  819. }
  820.  
  821.  
  822. #ifdef TODO
  823. #if defined(linux)
  824. #define IO_CLEANUP ;
  825. #endif
  826.  
  827. #ifdef IO_CLEANUP
  828.   IO_CLEANUP
  829. #else
  830. struct __io_defs {
  831.     __io_defs() { }
  832.     ~__io_defs() { _IO_cleanup(); }
  833. };   
  834. __io_defs io_defs__;
  835. #endif
  836.  
  837. #endif /* TODO */
  838.