NewtIO.c

説明を見る。

/*------------------------------------------------------------------------*/
/* ヘッダファイル */
#include <string.h>
#include <stdio.h>
#include <errno.h>

#include "NewtCore.h"
#include "NewtIO.h"

#if defined(HAVE_TERMIOS_H)
    #include <termios.h>
    #include <unistd.h>
    #include <sys/select.h>
#elif defined(__WIN32__)
    #include <conio.h>
#endif


/* マクロ */
#if defined(HAVE_TERMIOS_H)
    #define newt_getch()    tcgetch(0)
#elif defined(__WIN32__)
    #define newt_getch()    getch()
#else
    #define newt_getch()    (0)
#endif


/* 関数プロトタイプ */
static int  cbreak_and_noecho(int fd, int vmin, struct termios *tiosp);
static int  tcgetch(int fd);


/*------------------------------------------------------------------------*/
void NIOSetFile(newtStream_t * stream, FILE * f)
{
    stream->file = f;

    if (f == stdout)
        stream->obj = NcGetGlobalVar(NSSYM0(_STDOUT_));
    else if (f == stderr)
        stream->obj = NcGetGlobalVar(NSSYM0(_STDERR_));
    else
        stream->obj = kNewtRefUnbind;
}


/*------------------------------------------------------------------------*/
int NIOFprintf(newtStream_t * stream, const char * format, ...)
{
    va_list args;
    int     result;

    va_start(args, format);
    result = NIOVfprintf(stream, format, args);
    va_end(args);

    return result;
}


/*------------------------------------------------------------------------*/
int NIOVfprintf(newtStream_t * stream, const char * format, va_list ap)
{
    int     result = 0;

    if (NewtRefIsString(stream->obj))
    {
        char    wk[NEWT_SNPRINTF_BUFFSIZE];

        result = vsnprintf(wk, sizeof(wk), format, ap);

        if (0 < result)
        {
            if (sizeof(wk) < result)
                wk[sizeof(wk) - 1] = '0';

            NewtStrCat(stream->obj, wk);
        }
    }
    else
    {
        result = vfprintf(stream->file, format, ap);
    }

    return result;
}


/*------------------------------------------------------------------------*/
int NIOFputc(int c, newtStream_t * stream)
{
    int     result = 0;

    if (NewtRefIsString(stream->obj))
    {
        char    wk[4];

        sprintf(wk, "%c", c);
        NewtStrCat(stream->obj, wk);
    }
    else
    {
        result = fputc(c, stream->file);
    }

    return result;
}


/*------------------------------------------------------------------------*/
int NIOFputs(const char *str, newtStream_t * stream)
{
    int     result = 0;

    if (NewtRefIsString(stream->obj))
    {
        NewtStrCat(stream->obj, (char *)str);
    }
    else
    {
        result = fputs(str, stream->file);
    }

    return result;
}


#pragma mark -
/*------------------------------------------------------------------------*/
int NewtFprintf(FILE * f, const char * format, ...)
{
    newtStream_t    stream;
    va_list args;
    int     result;

    NIOSetFile(&stream, f);

    va_start(args, format);
    result = NIOVfprintf(&stream, format, args);
    va_end(args);

    return result;
}


/*------------------------------------------------------------------------*/
int NewtFputc(int c, FILE * f)
{
    newtStream_t    stream;

    NIOSetFile(&stream, f);
    return NIOFputc(c, &stream);
}


/*------------------------------------------------------------------------*/
int NewtFputs(const char *str, FILE * f)
{
    newtStream_t    stream;

    NIOSetFile(&stream, f);
    return NIOFputs(str, &stream);
}


#pragma mark -
/*------------------------------------------------------------------------*/
int NewtDebugMsg(const char * title, const char * format, ...)
{
    newtStream_t    stream;
    va_list args;
    int     result;

    NIOSetFile(&stream, stderr);

    if (title != NULL)
    {
        NIOFputs("[", &stream);
        NIOFputs(title, &stream);
        NIOFputs("] ", &stream);
    }

    va_start(args, format);
    result = NIOVfprintf(&stream, format, args);
    va_end(args);

    return result;
}


#pragma mark -
/*------------------------------------------------------------------------*/
newtRef NewtFgets(FILE * stream)
{
    newtRefVar  result = kNewtRefNIL;
    char    buff[NEWT_FGETS_BUFFSIZE];
    char *  str;
    char    c;
    int     maxsize;
    int     oldlen;
    int     len;

    maxsize = sizeof(buff) - 1;

    while (str = fgets(buff, sizeof(buff), stream))
    {
        len = strlen(str);

        if (result == kNewtRefNIL)
        {   // 文字列オブジェクト作成
            result = NewtMakeString2(str, len, false);

            if (NewtRefIsNIL(result))
            {   // メモリを確保できなかった
                return NewtThrow0(kNErrOutOfObjectMemory);
            }
        }
        else
        {   // 追加
            oldlen = NewtStringLength(result);
            result = NewtStrCat2(result, str, len);

            if (NewtStringLength(result) < oldlen + len)
            {   // メモリを確保できなかった
                return NewtThrow0(kNErrOutOfObjectMemory);
            }
        }

        if (len < maxsize)
            break;

        // 最後の文字をチェック
        c = buff[maxsize - 1];

        if (c == 'n')
            break;

        if (c == 'r')
        {
            // １文字先読み
            c = fgetc(stream);

            if (c != 'n')
            {   // CRLF でない（CR のみ）場合
                // 先読みした文字をストリームに戻す
                ungetc(c, stream);
                break;
            }
        }
    }

    return result;
}


/*------------------------------------------------------------------------*/
newtRef NsGets(newtRefArg rcvr)
{
    return NewtFgets(stdin);
}


/*------------------------------------------------------------------------*/
newtRef NewtFgetc(FILE * stream)
{
    int     c;

    c = fgetc(stream);

    if (c == EOF)
        return kNewtRefNIL;
    else
        return NewtMakeCharacter(c);
}


/*------------------------------------------------------------------------*/
newtRef NsGetc(newtRefArg rcvr)
{
    return NewtFgetc(stdin);
}


#ifdef HAVE_TERMIOS_H

/*------------------------------------------------------------------------*/
int cbreak_and_noecho(int fd, int vmin, struct termios *tiosp)
{
    struct termios  tios;
    int     err;

    err = tcgetattr(fd, &tios);
    if (err) return err;

    if (tiosp) *tiosp = tios;

    tios.c_lflag &=  (ICANON | ECHO);
    tios.c_cc[VTIME] = 0;
    tios.c_cc[VMIN] = vmin;
    err = tcsetattr(fd, TCSANOW, &tios);

    return err;
}


/*------------------------------------------------------------------------*/
int tcgetch(int fd)
{
    struct termios  tios;
    char    buf[1];
    int     c = 0;
    int     err;

    err = cbreak_and_noecho(fd, 1, &tios);
    if (err) return -1;

    if (0 < read(fd, buf, sizeof(buf)))
        c = buf[0];

    tcsetattr(fd, TCSANOW, &tios);

    return c;
}


#endif /* HAVE_TERMIOS_H */


/*------------------------------------------------------------------------*/
newtRef NsGetch(newtRefArg rcvr)
{
    int     c;

    c = newt_getch();

    if (c)
        return NewtMakeCharacter(c);
    else
        return kNewtRefNIL;
}

---