/*------------------------------------------------------------
* Vport puts
*/
static void vport_puts(ScmString *s, ScmPort *p)
{
vport *data = (vport*)p->src.vt.data;
const ScmStringBody *b = SCM_STRING_BODY(s);
SCM_ASSERT(data != NULL);
if (!SCM_FALSEP(data->puts_proc)) {
Scm_ApplyRec(data->puts_proc, SCM_LIST1(SCM_OBJ(s)));
} else if (SCM_STRING_BODY_INCOMPLETE_P(b)
|| (SCM_FALSEP(data->putc_proc)
&& !SCM_FALSEP(data->putb_proc))) {
/* we perform binary output */
vport_putz(SCM_STRING_BODY_START(b), SCM_STRING_BODY_SIZE(b), p);
} else if (!SCM_FALSEP(data->putc_proc)) {
ScmChar c;
int i;
const char *cp = SCM_STRING_BODY_START(b);
for (i=0; i < (int)SCM_STRING_BODY_LENGTH(b); i++) {
SCM_CHAR_GET(cp, c);
cp += SCM_CHAR_NFOLLOWS(*cp)+1;
Scm_ApplyRec(data->putc_proc, SCM_LIST1(SCM_MAKE_CHAR(c)));
}
} else {
Scm_PortError(p, SCM_PORT_ERROR_OTHER,
"cannot perform output to the port %S", p);
}
}
void Scm_PutbUnsafe(ScmByte b, ScmPort *p)
#endif
{
VMDECL;
SHORTCUT(p, Scm_PutbUnsafe(b, p); return);
WALKER_CHECK(p);
LOCK(p);
CLOSE_CHECK(p);
switch (SCM_PORT_TYPE(p)) {
case SCM_PORT_FILE:
if (p->src.buf.current >= p->src.buf.end) {
SAFE_CALL(p, bufport_flush(p, (int)(p->src.buf.current - p->src.buf.buffer), FALSE));
}
SCM_ASSERT(p->src.buf.current < p->src.buf.end);
*p->src.buf.current++ = b;
if (SCM_PORT_BUFFER_MODE(p) == SCM_PORT_BUFFER_NONE) {
SAFE_CALL(p, bufport_flush(p, 1, FALSE));
}
UNLOCK(p);
break;
case SCM_PORT_OSTR:
SCM_DSTRING_PUTB(&p->src.ostr, b);
UNLOCK(p);
break;
case SCM_PORT_PROC:
SAFE_CALL(p, p->src.vt.Putb(b, p));
UNLOCK(p);
break;
default:
UNLOCK(p);
Scm_PortError(p, SCM_PORT_ERROR_OUTPUT,
"bad port type for output: %S", p);
}
}
static int getc_scratch_unsafe(ScmPort *p)
#endif
{
char tbuf[SCM_CHAR_MAX_BYTES];
int nb = SCM_CHAR_NFOLLOWS(p->scratch[0]);
int curr = p->scrcnt;
memcpy(tbuf, p->scratch, curr);
p->scrcnt = 0;
for (int i=curr; i<=nb; i++) {
int r = EOF;
SAFE_CALL(p, r = Scm_Getb(p));
if (r == EOF) {
UNLOCK(p);
Scm_PortError(p, SCM_PORT_ERROR_INPUT,
"encountered EOF in middle of a multibyte character from port %S", p);
}
tbuf[i] = (char)r;
}
int ch;
SCM_CHAR_GET(tbuf, ch);
if (ch == SCM_CHAR_INVALID) {
/* This can happen if the input contains invalid byte sequence.
We return the stray byte (which would eventually result
an incomplete string when accumulated), while keeping the
remaining bytes in the scrach buffer. */
ch = (ScmChar)(tbuf[0] & 0xff);
memcpy(p->scratch, tbuf+1, nb);
p->scrcnt = nb;
}
return ch;
}
void Scm_FlushUnsafe(ScmPort *p)
#endif
{
VMDECL;
SHORTCUT(p, Scm_FlushUnsafe(p); return);
WALKER_CHECK(p);
LOCK(p);
CLOSE_CHECK(p);
switch (SCM_PORT_TYPE(p)) {
case SCM_PORT_FILE:
SAFE_CALL(p, bufport_flush(p, 0, TRUE));
UNLOCK(p);
break;
case SCM_PORT_OSTR:
UNLOCK(p);
break;
case SCM_PORT_PROC:
SAFE_CALL(p, p->src.vt.Flush(p));
UNLOCK(p);
break;
default:
UNLOCK(p);
Scm_PortError(p, SCM_PORT_ERROR_OUTPUT,
"bad port type for output: %S", p);
}
}
int Scm_GetzUnsafe(char *buf, int buflen, ScmPort *p)
#endif
{
VMDECL;
SHORTCUT(p, return Scm_GetzUnsafe(buf, buflen, p));
LOCK(p);
CLOSE_CHECK(p);
if (p->scrcnt) {
int r = GETZ_SCRATCH(buf, buflen, p);
UNLOCK(p);
return r;
}
if (p->ungotten != SCM_CHAR_INVALID) {
p->scrcnt = SCM_CHAR_NBYTES(p->ungotten);
SCM_CHAR_PUT(p->scratch, p->ungotten);
p->ungotten = SCM_CHAR_INVALID;
int r = GETZ_SCRATCH(buf, buflen, p);
UNLOCK(p);
return r;
}
switch (SCM_PORT_TYPE(p)) {
case SCM_PORT_FILE: {
int siz = 0;
SAFE_CALL(p, siz = bufport_read(p, buf, buflen));
p->bytes += siz;
UNLOCK(p);
if (siz == 0) return EOF;
else return siz;
}
case SCM_PORT_ISTR: {
int r = GETZ_ISTR(p, buf, buflen);
p->bytes += r;
UNLOCK(p);
return r;
}
case SCM_PORT_PROC: {
int r = 0;
SAFE_CALL(p, r = p->src.vt.Getz(buf, buflen, p));
p->bytes += r;
UNLOCK(p);
return r;
}
default:
UNLOCK(p);
Scm_PortError(p, SCM_PORT_ERROR_INPUT, "bad port type for input: %S", p);
}
return -1; /* dummy */
}
void Scm_UngetbUnsafe(int b, ScmPort *p)
#endif
{
VMDECL;
SHORTCUT(p, Scm_UngetbUnsafe(b, p); return);
LOCK(p);
if (p->ungotten != SCM_CHAR_INVALID
|| p->scrcnt >= SCM_CHAR_MAX_BYTES) {
Scm_PortError(p, SCM_PORT_ERROR_INPUT,
"pushback buffer overflow on port %S", p);
}
p->scratch[p->scrcnt++] = b;
UNLOCK(p);
}
void Scm_UngetcUnsafe(ScmChar c, ScmPort *p)
#endif
{
VMDECL;
SHORTCUT(p, Scm_UngetcUnsafe(c, p); return);
LOCK(p);
if (p->ungotten != SCM_CHAR_INVALID
|| p->scrcnt != 0) {
Scm_PortError(p, SCM_PORT_ERROR_INPUT,
"pushback buffer overflow on port %S", p);
}
p->ungotten = c;
UNLOCK(p);
}
int Scm_GetbUnsafe(ScmPort *p)
#endif
{
int b = 0;
VMDECL;
SHORTCUT(p, return Scm_GetbUnsafe(p));
LOCK(p);
CLOSE_CHECK(p);
/* check if there's "pushed back" stuff */
if (p->scrcnt) {
b = getb_scratch(p);
} else if (p->ungotten != SCM_CHAR_INVALID) {
b = getb_ungotten(p);
} else {
switch (SCM_PORT_TYPE(p)) {
case SCM_PORT_FILE:
if (p->src.buf.current >= p->src.buf.end) {
int r = 0;
SAFE_CALL(p, r = bufport_fill(p, 1, FALSE));
if (r == 0) {
UNLOCK(p);
return EOF;
}
}
b = (unsigned char)*p->src.buf.current++;
break;
case SCM_PORT_ISTR:
if (p->src.istr.current >= p->src.istr.end) b = EOF;
else b = (unsigned char)*p->src.istr.current++;
break;
case SCM_PORT_PROC:
SAFE_CALL(p, b = p->src.vt.Getb(p));
break;
default:
UNLOCK(p);
Scm_PortError(p, SCM_PORT_ERROR_INPUT,
"bad port type for input: %S", p);
}
p->bytes++;
}
UNLOCK(p);
return b;
}
void Scm_PutsUnsafe(ScmString *s, ScmPort *p)
#endif
{
VMDECL;
SHORTCUT(p, Scm_PutsUnsafe(s, p); return);
WALKER_CHECK(p);
LOCK(p);
CLOSE_CHECK(p);
switch (SCM_PORT_TYPE(p)) {
case SCM_PORT_FILE: {
u_int size;
const char *ss = Scm_GetStringContent(s, &size, NULL, NULL);
SAFE_CALL(p, bufport_write(p, ss, size));
if (SCM_PORT_BUFFER_MODE(p) == SCM_PORT_BUFFER_LINE) {
const char *cp = p->src.buf.current;
while (cp-- > p->src.buf.buffer) {
if (*cp == '\n') {
SAFE_CALL(p, bufport_flush(p, (int)(cp - p->src.buf.current), FALSE));
break;
}
}
} else if (SCM_PORT_BUFFER_MODE(p) == SCM_PORT_BUFFER_NONE) {
SAFE_CALL(p, bufport_flush(p, 0, TRUE));
}
UNLOCK(p);
break;
}
case SCM_PORT_OSTR:
Scm_DStringAdd(&p->src.ostr, s);
UNLOCK(p);
break;
case SCM_PORT_PROC:
SAFE_CALL(p, p->src.vt.Puts(s, p));
UNLOCK(p);
break;
default:
UNLOCK(p);
Scm_PortError(p, SCM_PORT_ERROR_OUTPUT,
"bad port type for output: %S", p);
}
}
/*------------------------------------------------------------
* Vport putz
*/
static void vport_putz(const char *buf, int size, ScmPort *p)
{
vport *data = (vport*)p->src.vt.data;
SCM_ASSERT(data != NULL);
if (!SCM_FALSEP(data->puts_proc)) {
Scm_ApplyRec(data->puts_proc,
SCM_LIST1(Scm_MakeString(buf, size, -1,
SCM_STRING_COPYING)));
} else if (!SCM_FALSEP(data->putb_proc)) {
for (int i=0; i<size; i++) {
unsigned char b = buf[i];
Scm_ApplyRec(data->putb_proc, SCM_LIST1(SCM_MAKE_INT(b)));
}
} else {
Scm_PortError(p, SCM_PORT_ERROR_UNIT,
"cannot perform binary output to the port %S", p);
}
}
void Scm_PutcUnsafe(ScmChar c, ScmPort *p)
#endif
{
VMDECL;
SHORTCUT(p, Scm_PutcUnsafe(c, p); return);
WALKER_CHECK(p);
LOCK(p);
CLOSE_CHECK(p);
switch (SCM_PORT_TYPE(p)) {
case SCM_PORT_FILE: {
int nb = SCM_CHAR_NBYTES(c);
if (p->src.buf.current+nb > p->src.buf.end) {
SAFE_CALL(p, bufport_flush(p, (int)(p->src.buf.current - p->src.buf.buffer), FALSE));
}
SCM_ASSERT(p->src.buf.current+nb <= p->src.buf.end);
SCM_CHAR_PUT(p->src.buf.current, c);
p->src.buf.current += nb;
if (SCM_PORT_BUFFER_MODE(p) == SCM_PORT_BUFFER_LINE) {
if (c == '\n') {
SAFE_CALL(p, bufport_flush(p, nb, FALSE));
}
} else if (SCM_PORT_BUFFER_MODE(p) == SCM_PORT_BUFFER_NONE) {
SAFE_CALL(p, bufport_flush(p, nb, FALSE));
}
UNLOCK(p);
break;
}
case SCM_PORT_OSTR:
SCM_DSTRING_PUTC(&p->src.ostr, c);
UNLOCK(p);
break;
case SCM_PORT_PROC:
SAFE_CALL(p, p->src.vt.Putc(c, p));
UNLOCK(p);
break;
default:
UNLOCK(p);
Scm_PortError(p, SCM_PORT_ERROR_OUTPUT,
"bad port type for output: %S", p);
}
}
/*------------------------------------------------------------
* Vport putb
*/
static void vport_putb(ScmByte b, ScmPort *p)
{
vport *data = (vport*)p->src.vt.data;
SCM_ASSERT(data != NULL);
if (SCM_FALSEP(data->putb_proc)) {
if (!SCM_FALSEP(data->putc_proc)
&& SCM_CHAR_NFOLLOWS(b) == 0) {
/* This byte is a single-byte character, so we can use putc. */
Scm_ApplyRec(data->putc_proc, SCM_LIST1(SCM_MAKE_CHAR(b)));
} else {
/* Given byte is a part of multibyte sequence. We don't
handle it for the time being. */
Scm_PortError(p, SCM_PORT_ERROR_UNIT,
"cannot perform binary output to the port %S", p);
}
} else {
Scm_ApplyRec(data->putb_proc, SCM_LIST1(SCM_MAKE_INT(b)));
}
}
/*------------------------------------------------------------
* Vport putc
*/
static void vport_putc(ScmChar c, ScmPort *p)
{
vport *data = (vport*)p->src.vt.data;
SCM_ASSERT(data != NULL);
if (SCM_FALSEP(data->putc_proc)) {
if (SCM_FALSEP(data->putb_proc)) {
Scm_PortError(p, SCM_PORT_ERROR_OTHER,
"cannot perform output to the port %S", p);
} else {
unsigned char buf[SCM_CHAR_MAX_BYTES];
int i, n=SCM_CHAR_NBYTES(c);
SCM_CHAR_PUT(buf, c);
for (i=0; i<n; i++) {
Scm_ApplyRec(data->putb_proc, SCM_LIST1(SCM_MAKE_INT(buf[i])));
}
}
} else {
Scm_ApplyRec(data->putc_proc, SCM_LIST1(SCM_MAKE_CHAR(c)));
}
}
void Scm_PutzUnsafe(const char *s, int siz, ScmPort *p)
#endif
{
VMDECL;
SHORTCUT(p, Scm_PutzUnsafe(s, siz, p); return);
WALKER_CHECK(p);
LOCK(p);
CLOSE_CHECK(p);
if (siz < 0) siz = (int)strlen(s);
switch (SCM_PORT_TYPE(p)) {
case SCM_PORT_FILE:
SAFE_CALL(p, bufport_write(p, s, siz));
if (SCM_PORT_BUFFER_MODE(p) == SCM_PORT_BUFFER_LINE) {
const char *cp = p->src.buf.current;
while (cp-- > p->src.buf.buffer) {
if (*cp == '\n') {
SAFE_CALL(p, bufport_flush(p, (int)(cp - p->src.buf.current), FALSE));
break;
}
}
} else if (SCM_PORT_BUFFER_MODE(p) == SCM_PORT_BUFFER_NONE) {
SAFE_CALL(p, bufport_flush(p, 0, TRUE));
}
UNLOCK(p);
break;
case SCM_PORT_OSTR:
Scm_DStringPutz(&p->src.ostr, s, siz);
UNLOCK(p);
break;
case SCM_PORT_PROC:
SAFE_CALL(p, p->src.vt.Putz(s, siz, p));
UNLOCK(p);
break;
default:
UNLOCK(p);
Scm_PortError(p, SCM_PORT_ERROR_OUTPUT,
"bad port type for output: %S", p);
}
}
int Scm_GetcUnsafe(ScmPort *p)
#endif
{
VMDECL;
SHORTCUT(p, return Scm_GetcUnsafe(p));
LOCK(p);
CLOSE_CHECK(p);
if (p->scrcnt > 0) {
int r = GETC_SCRATCH(p);
UNLOCK(p);
return r;
}
if (p->ungotten != SCM_CHAR_INVALID) {
int c = p->ungotten;
p->ungotten = SCM_CHAR_INVALID;
UNLOCK(p);
return c;
}
switch (SCM_PORT_TYPE(p)) {
case SCM_PORT_FILE: {
int c = 0;
if (p->src.buf.current >= p->src.buf.end) {
int r = 0;
SAFE_CALL(p, r = bufport_fill(p, 1, FALSE));
if (r == 0) {
UNLOCK(p);
return EOF;
}
}
int first = (unsigned char)*p->src.buf.current++;
int nb = SCM_CHAR_NFOLLOWS(first);
p->bytes++;
if (nb > 0) {
if (p->src.buf.current + nb > p->src.buf.end) {
/* The buffer doesn't have enough bytes to consist a char.
move the incomplete char to the scratch buffer and try
to fetch the rest of the char. */
int rest, filled = 0;
p->scrcnt = (unsigned char)(p->src.buf.end - p->src.buf.current + 1);
memcpy(p->scratch, p->src.buf.current-1, p->scrcnt);
p->src.buf.current = p->src.buf.end;
rest = nb + 1 - p->scrcnt;
for (;;) {
SAFE_CALL(p, filled = bufport_fill(p, rest, FALSE));
if (filled <= 0) {
/* TODO: make this behavior customizable */
UNLOCK(p);
Scm_PortError(p, SCM_PORT_ERROR_INPUT,
"encountered EOF in middle of a multibyte character from port %S", p);
}
if (filled >= rest) {
memcpy(p->scratch+p->scrcnt, p->src.buf.current, rest);
p->scrcnt += rest;
p->src.buf.current += rest;
break;
} else {
memcpy(p->scratch+p->scrcnt, p->src.buf.current, filled);
p->scrcnt += filled;
p->src.buf.current = p->src.buf.end;
rest -= filled;
}
}
SCM_CHAR_GET(p->scratch, c);
p->scrcnt = 0;
} else {
SCM_CHAR_GET(p->src.buf.current-1, c);
p->src.buf.current += nb;
}
p->bytes += nb;
} else {
c = first;
if (c == '\n') p->line++;
}
UNLOCK(p);
return c;
}
case SCM_PORT_ISTR: {
if (p->src.istr.current >= p->src.istr.end) {
UNLOCK(p);
return EOF;
}
int c = 0;
int first = (unsigned char)*p->src.istr.current++;
int nb = SCM_CHAR_NFOLLOWS(first);
p->bytes++;
if (nb > 0) {
if (p->src.istr.current + nb > p->src.istr.end) {
/* TODO: make this behavior customizable */
UNLOCK(p);
Scm_PortError(p, SCM_PORT_ERROR_INPUT,
"encountered EOF in middle of a multibyte character from port %S", p);
}
SCM_CHAR_GET(p->src.istr.current-1, c);
p->src.istr.current += nb;
p->bytes += nb;
} else {
c = first;
if (c == '\n') p->line++;
}
UNLOCK(p);
return c;
}
case SCM_PORT_PROC: {
int c = 0;
SAFE_CALL(p, c = p->src.vt.Getc(p));
if (c == '\n') p->line++;
UNLOCK(p);
return c;
}
default:
UNLOCK(p);
Scm_PortError(p, SCM_PORT_ERROR_INPUT, "bad port type for input: %S", p);
}
return 0;/*dummy*/
}
ScmObj Scm_PortSeekUnsafe(ScmPort *p, ScmObj off, int whence)
#endif
{
VMDECL;
SHORTCUT(p, return Scm_PortSeekUnsafe(p, off, whence));
if (SCM_PORT_CLOSED_P(p)) {
Scm_PortError(p, SCM_PORT_ERROR_CLOSED,
"attempt to seek on closed port: %S", p);
}
off_t r = (off_t)-1;
off_t o = Scm_IntegerToOffset(off);
int is_telling = (whence == SEEK_CUR && o == 0);
LOCK(p);
off_t pending = port_pending_bytes(p);
if (!is_telling) {
/* Unless we're telling, we discard pending bytes. */
p->scrcnt = 0;
p->ungotten = SCM_CHAR_INVALID;
/* ... and adjust offset, when it's relative. */
if (whence == SEEK_CUR) o -= pending;
}
switch (SCM_PORT_TYPE(p)) {
case SCM_PORT_FILE:
/* NB: we might be able to skip calling seeker if we keep the
# of bytes read or write so far, but such count may be off
when the port has been experienced an error condition. */
/* NB: the following doesn't work if we have bidirectional port.
In such case we need to keep whether the last call of buffer
handling routine was input or output. */
if (!p->src.buf.seeker) break;
if (is_telling) {
SAFE_CALL(p, r = p->src.buf.seeker(p, 0, SEEK_CUR));
if (SCM_PORT_DIR(p)&SCM_PORT_INPUT) {
r -= (off_t)(p->src.buf.end - p->src.buf.current);
} else {
r += (off_t)(p->src.buf.current - p->src.buf.buffer);
}
} else {
/* NB: possible optimization: the specified position is within
the current buffer, we can avoid calling seeker. */
if (SCM_PORT_DIR(p)&SCM_PORT_INPUT) {
char *c = p->src.buf.current; /* save current ptr */
if (whence == SEEK_CUR) {
o -= (off_t)(p->src.buf.end - c);
}
p->src.buf.current = p->src.buf.end; /* invalidate buffer */
SAFE_CALL(p, r = p->src.buf.seeker(p, o, whence));
if (r == (off_t)-1) {
/* This may happend if seeker somehow gave up */
p->src.buf.current = c;
}
} else {
SAFE_CALL(p, bufport_flush(p, 0, TRUE));
SAFE_CALL(p, r = p->src.buf.seeker(p, o, whence));
}
}
break;
case SCM_PORT_ISTR:
r = SEEK_ISTR(p, o, whence, is_telling);
break;
case SCM_PORT_OSTR:
if (is_telling) {
r = (off_t)Scm_DStringSize(&(p->src.ostr));
} else {
/* Not supported yet */
r = (off_t)-1;
}
break;
case SCM_PORT_PROC:
if (p->src.vt.Seek) {
SAFE_CALL(p, r = p->src.vt.Seek(p, o, whence));
}
break;
}
UNLOCK(p);
if (r == (off_t)-1) return SCM_FALSE;
if (is_telling) r -= pending;
return Scm_OffsetToInteger(r);
}
