169 lines
3.6 KiB
C
169 lines
3.6 KiB
C
/* stdio on a Mach device port.
|
|
Translates \n to \r on output.
|
|
|
|
Copyright (C) 1992 Free Software Foundation, Inc.
|
|
This file is part of the GNU C Library.
|
|
|
|
The GNU C Library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public License as
|
|
published by the Free Software Foundation; either version 2 of the
|
|
License, or (at your option) any later version.
|
|
|
|
The GNU C Library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public
|
|
License along with the GNU C Library; see the file COPYING.LIB. If
|
|
not, write to the Free Software Foundation, Inc., 675 Mass Ave,
|
|
Cambridge, MA 02139, USA. */
|
|
|
|
#include <ansidecl.h>
|
|
#include <stdio.h>
|
|
#include <mach.h>
|
|
#include <mach/device.h>
|
|
|
|
static int
|
|
input (FILE *f)
|
|
{
|
|
error_t err;
|
|
char *buffer;
|
|
size_t to_read;
|
|
char c;
|
|
|
|
if (f->__buffer == NULL)
|
|
{
|
|
buffer = &c;
|
|
to_read = 1;
|
|
}
|
|
else
|
|
{
|
|
buffer = f->__buffer;
|
|
to_read = f->__bufsize;
|
|
}
|
|
|
|
f->__eof = 0;
|
|
|
|
if (err = device_read_inband ((device_t) cookie, 0, f->__target, to_read,
|
|
buffer, &nread))
|
|
{
|
|
f->__error = 1;
|
|
f->__bufp = f->__get_limit = f->__put_limit = f->__buffer;
|
|
errno = err;
|
|
return EOF;
|
|
}
|
|
|
|
if (f->__buffer == NULL)
|
|
return (unsigned char) c;
|
|
|
|
f->__get_limit = f->__buffer + nread;
|
|
f->__bufp = f->__buffer;
|
|
f->__put_limit = f->__buffer + (f->__mode.__write ? f->__bufsize : 0);
|
|
return (unsigned char *) *f->__bufp++;
|
|
}
|
|
|
|
static void
|
|
output (FILE *f, int c)
|
|
{
|
|
error_t err;
|
|
size_t to_write;
|
|
char *p;
|
|
|
|
if (f->__buffer == NULL)
|
|
{
|
|
if (c != EOF)
|
|
{
|
|
char cc = (unsigned char) c;
|
|
int wrote;
|
|
if (cc == '\n')
|
|
cc = '\r';
|
|
if ((err = device_write_inband ((device_t) f->__cookie, 0,
|
|
f->__target, &cc, 1, &wrote)) ||
|
|
wrote != 1)
|
|
{
|
|
errno = err;
|
|
f->__error = 1;
|
|
}
|
|
}
|
|
++f->__target;
|
|
return;
|
|
}
|
|
|
|
if (f->__put_limit == f->__buffer)
|
|
{
|
|
f->__put_limit = f->__buffer + f->__bufsize;
|
|
f->__bufp = f->__buffer;
|
|
if (c != EOF)
|
|
{
|
|
*f->__bufp++ = (unsigned char) c;
|
|
c = EOF;
|
|
}
|
|
}
|
|
|
|
to_write = f->__bufp - f->__buffer;
|
|
p = f->__buffer;
|
|
while (1)
|
|
{
|
|
char *p2 = memchr (p, '\n', to_write);
|
|
if (p2 == NULL)
|
|
break;
|
|
*p2++ = '\r';
|
|
to_write -= p2 - p;
|
|
p = p2;
|
|
}
|
|
|
|
to_write = f->__bufp - f->__buffer;
|
|
p = f->__buffer;
|
|
while (to_write > 0)
|
|
{
|
|
int wrote;
|
|
if (err = device_write_inband ((device_t) f->__cookie, 0, f->__target,
|
|
p, to_write, &wrote))
|
|
{
|
|
errno = EIO;
|
|
f->__error = 1;
|
|
break;
|
|
}
|
|
p += wrote;
|
|
to_write -= wrote;
|
|
f->__target += wrote;
|
|
}
|
|
|
|
f->__bufp = f->__buffer;
|
|
|
|
if (c != EOF && !ferror (f))
|
|
{
|
|
if (f->__linebuf && (unsigned char) c == '\n')
|
|
{
|
|
static const char nl = '\r';
|
|
if ((err = device_write_inband ((device_t) f->__cookie, 0,
|
|
f->__target, &nl, 1, &wrote)) ||
|
|
wrote != 1)
|
|
{
|
|
errno = EIO;
|
|
f->__error = 1;
|
|
}
|
|
else
|
|
++f->__target;
|
|
}
|
|
else
|
|
*f->__bufp++ = (unsigned char) c;
|
|
}
|
|
}
|
|
|
|
FILE *
|
|
mach_open_devstream (device_t dev, const char *mode)
|
|
{
|
|
FILE *stream = fopencookie (dev, mode, __default_io_functions);
|
|
if (stream == NULL)
|
|
return NULL;
|
|
|
|
stream->__room_funcs.__input = input;
|
|
stream->__room_funcs.__output = output;
|
|
stream->__io_funcs.__close = device_close;
|
|
stream->__seen = 1;
|
|
|
|
retrun stream;
|
|
}
|