stdio_os1.h

Go to the documentation of this file.

/* =============
 * apeNEXT/nlibc
 * =============
 *
 * $Id: stdio_os1.h,v 1.37 2006/05/06 14:42:24 pleiter Exp $
 * -------------------------------------------------------------------------- */

#ifndef _NLIBC_OS1_STDIO_H
#define _NLIBC_OS1_STDIO_H

#include <nlibc.h>

#include <os1/defs_os1.h>
#include <errno.h>
#include <stddef.h>
#include <string.h>             // for strerror etc.
#include <stdarg.h>             // for va_list etc.
#include <typecodes.h>          // nlcc type codes


//------------------------------------------------------------------------------
// OS0 compatibility routines
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#if !defined(__cflow_processed) || defined(_uses_write_int_stdio_os1_h)
inline void write_int(int i)
{
   asm("\t$io_start\n"
       "\t$io_fd($SYS_IOFD_STDOUT)\n"
       "\t\\equl $cmd   $SYS_IOCMD_GWR\n"
       "\t\\equl $fmt   $SYS_IOFMT_INT\n"
       "\t\\equl $sep   <$SYS_IOPSEP_NL .or. $SYS_IOWSEP_NL>\n"
       "\t\\equl $dev   $SYS_IODEV_MEM\n"
       "\t\\equl $l     1\n"
       "\t\\equl $bs    $SYS_IOBS_L\n"
       "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"
       "\t\\equl $addr  0x0.%0\n"
       "\t$io_packet($cmd, <$fmt .or. $sep>, $rdflg, $dev, $l, $bs, $addr)\n"
       "\t$io_end\n" : : "r" (&i));
}
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#if !defined(__cflow_processed) || defined(_uses_write_int_array_stdio_os1_h)
inline void write_int_array(int *ip, int size)
{
   asm("\t$io_start\n"
       "\t$io_fd($SYS_IOFD_STDOUT)\n"
       "\t\\equl $cmd   $SYS_IOCMD_GWR\n"
       "\t\\equl $fmt   $SYS_IOFMT_INT\n"
       "\t\\equl $sep   <$SYS_IOPSEP_NL .or. $SYS_IOWSEP_SPACE>\n"
       "\t\\equl $dev   $SYS_IODEV_MEM\n"
       "\t\\equl $l     0.%1\n"
       "\t\\equl $bs    $SYS_IOBS_L\n"
       "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"
       "\t$io_packet($cmd, <$fmt .or. $sep>, 0, $dev, $l, $bs, 0.%0)\n"
       "\t$io_end\n" : : "r" (ip), "r" (size) );
}
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#if !defined(__cflow_processed) || defined(_uses_write_float_stdio_os1_h)
inline void write_float(float f)
{
   asm("\t$io_start\n"
       "\t$io_fd($SYS_IOFD_STDOUT)\n"
       "\t\\equl $cmd   $SYS_IOCMD_GWR\n"
       "\t\\equl $fmt   $SYS_IOFMT_DBL\n"
       "\t\\equl $sep   <$SYS_IOPSEP_NL .or. $SYS_IOWSEP_NL>\n"
       "\t\\equl $dev   $SYS_IODEV_MEM\n"
       "\t\\equl $l     1\n"
       "\t\\equl $bs    $SYS_IOBS_L\n"
       "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"
       "\t\\equl $addr  0x0.%0\n"
       "\t$io_packet($cmd, <$fmt .or. $sep>, $rdflg, $dev, $l, $bs, $addr)\n"
       "\t$io_end\n" : : "r" (&f));
}
#endif

#define write_double write_float


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#if !defined(__cflow_processed) || defined(_uses_write_float_array_stdio_os1_h)
inline void write_float_array(float *fp, int size)
{
   asm("\t$io_start\n"
       "\t$io_fd($SYS_IOFD_STDOUT)\n"
       "\t\\equl $cmd   $SYS_IOCMD_GWR\n"
       "\t\\equl $fmt   $SYS_IOFMT_DBL\n"
       "\t\\equl $sep   <$SYS_IOPSEP_NL .or. $SYS_IOWSEP_SPACE>\n"
       "\t\\equl $dev   $SYS_IODEV_MEM\n"
       "\t\\equl $l     0.%1\n"
       "\t\\equl $bs    $SYS_IOBS_L\n"
       "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"
       "\t$io_packet($cmd, <$fmt .or. $sep>, 0, $dev, $l, $bs, 0.%0)\n"
       "\t$io_end\n" : : "r" (fp), "r" (size) );
}
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#if !defined(__cflow_processed) || defined(_uses_write_double_array_stdio_os1_h)
inline void write_double_array(double *fp, int size)
{
   asm("\t$io_start\n"
       "\t$io_fd($SYS_IOFD_STDOUT)\n"
       "\t\\equl $cmd   $SYS_IOCMD_GWR\n"
       "\t\\equl $fmt   $SYS_IOFMT_DBL\n"
       "\t\\equl $sep   <$SYS_IOPSEP_NL .or. $SYS_IOWSEP_SPACE>\n"
       "\t\\equl $dev   $SYS_IODEV_MEM\n"
       "\t\\equl $l     0.%1\n"
       "\t\\equl $bs    $SYS_IOBS_L\n"
       "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"
       "\t$io_packet($cmd, <$fmt .or. $sep>, 0, $dev, $l, $bs, 0.%0)\n"
       "\t$io_end\n" : : "r" (fp), "r" (size) );
}
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#if !defined(__cflow_processed) || defined(_uses_write_complex_stdio_os1_h)
inline void write_complex(complex c)
{ 
   asm("\t$io_start\n"
       "\t$io_fd($SYS_IOFD_STDOUT)\n"
       "\t\\equl $cmd   $SYS_IOCMD_GWR\n"
       "\t\\equl $fmt   $SYS_IOFMT_DBL\n"
       "\t\\equl $sep   <$SYS_IOPSEP_NL .or. $SYS_IOWSEP_SPACE .or. $SYS_IOBSEP_RBRACKET>\n"
       "\t\\equl $dev   $SYS_IODEV_MEM\n"
       "\t\\equl $l     1\n"
       "\t\\equl $bs    $SYS_IOBS_V\n"
       "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"
       "\t\\equl $addr  0x0.%0\n"
       "\t$io_packet($cmd, <$fmt .or. $sep>, $rdflg, $dev, $l, $bs, $addr)\n"
       "\t$io_end\n" : : "r" (&c));
} 
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#if !defined(__cflow_processed) || defined(_uses_write_complex_array_stdio_os1_h)
inline void write_complex_array(complex *cp, int size)
{
   asm("\t$io_start\n"
       "\t$io_fd($SYS_IOFD_STDOUT)\n"
       "\t\\equl $cmd   $SYS_IOCMD_GWR\n"
       "\t\\equl $fmt   $SYS_IOFMT_DBL\n"
       "\t\\equl $sep   <$SYS_IOPSEP_NL .or. $SYS_IOWSEP_SPACE .or. $SYS_IOBSEP_RBRACKET>\n"
       "\t\\equl $dev   $SYS_IODEV_MEM\n"
       "\t\\equl $l     0.%1\n"
       "\t\\equl $bs    $SYS_IOBS_V\n"
       "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"
       "\t$io_packet($cmd, <$fmt .or. $sep>, 0, $dev, $l, $bs, 0.%0)\n"
       "\t$io_end\n" : : "r" (cp), "r" (size) );
}
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#if !defined(__cflow_processed) || defined(_uses_write_vector_stdio_os1_h)
inline void write_vector(vector v)
{
   asm("\t$io_start\n"
       "\t$io_fd($SYS_IOFD_STDOUT)\n"
       "\t\\equl $cmd   $SYS_IOCMD_GWR\n"
       "\t\\equl $fmt   $SYS_IOFMT_DBL\n"
       "\t\\equl $sep   <$SYS_IOPSEP_NL .or. $SYS_IOWSEP_SPACE .or. $SYS_IOBSEP_RBRACKET>\n"
       "\t\\equl $dev   $SYS_IODEV_MEM\n"
       "\t\\equl $l     1\n"
       "\t\\equl $bs    $SYS_IOBS_V\n"
       "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"
       "\t\\equl $addr  0x0.%0\n"
       "\t$io_packet($cmd, <$fmt .or. $sep>, $rdflg, $dev, $l, $bs, $addr)\n"
       "\t$io_end\n" : : "r" (&v));
}
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#if !defined(__cflow_processed) || defined(_uses_write_vector_array_stdio_os1_h)
inline void write_vector_array(vector *vp, int size)
{
   asm("\t$io_start\n"
       "\t$io_fd($SYS_IOFD_STDOUT)\n"
       "\t\\equl $cmd   $SYS_IOCMD_GWR\n"
       "\t\\equl $fmt   $SYS_IOFMT_DBL\n"
       "\t\\equl $sep   <$SYS_IOPSEP_NL .or. $SYS_IOWSEP_SPACE .or. $SYS_IOBSEP_RBRACKET>\n"
       "\t\\equl $dev   $SYS_IODEV_MEM\n"
       "\t\\equl $l     0.%1\n"
       "\t\\equl $bs    $SYS_IOBS_V\n"
       "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"
       "\t$io_packet($cmd, <$fmt .or. $sep>, 0, $dev, $l, $bs, 0.%0)\n"
       "\t$io_end\n" : : "r" (vp), "r" (size) );
}
#endif

#define write_string(STR) fputs((STR),stdout)


//------------------------------------------------------------------------------
#define EOF (-1)


#ifndef _FPOS_T
#define _FPOS_T
typedef int fpos_t; 
#endif


#ifndef _FILE_T
#define _FILE_T
typedef __nlcc_file_struct FILE;
#endif


#define _IOFBF 0


#define _IOLBF 1


#define _IONBF 2


#define BUFSIZ 0


#define FOPEN_MAX  __NLCC_OS1_MAX_FILES__


#define FILENAME_MAX 4095


#define L_tmpnam 20


#define TMP_MAX  238328


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#if !defined(__cflow_processed) || defined(_uses_remove_stdio_os1_h)
inline int remove(const char *filename)
{
  int ret;
  vector int sys_rval;

  asm("\t$sys_sh($SYS_SHCMD_REMOVE, %1)\n"
      "\tlmtr %0 $MEM_SYS_RVAL\n"
      : "=r" (sys_rval) : "r" (filename));

  ret = 0;
  where (sys_rval.lo) {
    ret = -1;
  }
  where (sys_rval.lo == 1) {
    errno = sys_rval.hi;
  }

  return ret;
}
#endif // remove


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#if !defined(__cflow_processed) || defined(_uses_rename_stdio_os1_h)
inline int rename(const char *old, const char *new)
{
#ifdef __cflow_processed
# error "Not implemented yet"
#endif
} 
#endif // rename()


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#if !defined(__cflow_processed) || defined(_uses_tmpfile_stdio_os1_h)
inline FILE *tmpfile(void)
{
#ifdef __cflow_processed
# error "Not implemented yet"
#endif
} 
#endif 


//------------------------------------------------------------------------------
#if !defined(__cflow_processed) || defined(_uses_tmpnam_stdio_os1_h)
char *tmpnam(char *s)
{
#ifdef __cflow_processed
# error "Not implemented yet"
#endif
}
#endif // tmpnam()


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#if !defined(__cflow_processed) || defined(_uses_fflush_stdio_os1_h)
int fflush(FILE *stream)
{
#ifdef __cflow_processed
# warning "fflush(): dummy implementation"
  return 0;
#endif
}
#endif // fflush()


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#ifndef __HAS_MAIN
extern FILE *fopen (const char *path, const char *mode);
#else
#if !defined(__cflow_processed) || defined(_uses_fopen_stdio_os1_h)
FILE *fopen (const char *path, const char *mode)
{
    int modebits = 0;
    FILE* stream;
    #pragma localmem

    asm("\t!! start fopen()\n");

    /* check if number of open files exceeded */
    if( __n_files == __NLCC_OS1_MAX_FILES__ ) {
        errno = EMFILE;
        return NULL;
    }
    
    /* convert mode string into mode bits */
    /* return NULL for invalid mode       */
    {   
          int modevalue = *(unsigned *)mode;

          modebits = modevalue & 0xff;
          where( modebits == 'r' )
             asm("\t$io_setmode(%0, $SYS_IOMODE_R)\n" : "=r" (modebits) );
          where( modebits == 'w' )
             asm("\t$io_setmode(%0, $SYS_IOMODE_W)\n" : "=r" (modebits) );
          where( modebits == 'a' )
             asm("\t$io_setmode(%0, $SYS_IOMODE_A)\n" : "=r" (modebits) );
          where( ((modevalue & 0xff00)>>8) == '+' ) 
             modebits++;

          if( ! modebits ) {
                errno = EINVAL;
                return NULL;
          }
    }
    {   int fileno, fi;
        vector int sys_rval;

        for( fi=0; fi<__NLCC_OS1_MAX_FILES__; fi++ ) {
                if( __files[fi].fd == 0 ) {
                        fileno = __NLCC_BASE_FD + fi;
                        break;
                }
        }
        // unless we miscounted, fi _is_ now < __NLCC_OS1_MAX_FILES__

        asm("\t$io_start\n"
            "\t$io_fopenp( 0.%1, %2, 0.%3, $SYS_IODEV_MEM, \"\")\n"
            "\t$io_end\n"
            "\tlmtr %0 $MEM_SYS_RVAL\n"
            : "=r" (sys_rval)
            :  "r" (fileno), "r" (modebits), "r" (path) );

        stream = &__files[fi];
        stream->fd = fileno;
        stream->mode = modebits;
        stream->err = 0;

        // check OS1 return code and set errno if necessary
        // success: .L==0, fail: .L!=0
        where (sys_rval.lo) {
                errno = sys_rval.hi;
                stream = NULL;
        } else {
                __n_files++;
        }
    }
    asm("\t!! end fopen()\n");

    return stream;
}
#endif // fopen()
#endif // Has Main


//----------------------------------------------------------------------
//----------------------------------------------------------------------

#ifndef __HAS_MAIN
extern int fclose(FILE *stream);
#else
#if !defined(__cflow_processed) || defined(_uses_fclose_stdio_os1_h)
int fclose(FILE *stream)
{
        vector int sys_rval;
        int result;

        if( ! stream || ! stream->fd ) {
                errno = EBADF;
                return EOF;
        }

        asm("\t$io_start\n"
            "\t$io_fclose(0.%1)"
            "\t$io_end\n"
            "\tlmtr %0 $MEM_SYS_RVAL\n"
            : "=r" (sys_rval) : "r" (stream->fd));

        *stream = (__nlcc_file_struct){0,_SYS_IOMODE_CLOSED}; 
        __n_files--;

        result = 0;
        where (sys_rval.lo) {
                errno = sys_rval.hi;
                result = EOF;
                stream->err = 1;
        }

        return result;
}
#endif // fclose()
#endif // Has Main


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#ifndef __HAS_MAIN
extern FILE *freopen(const char * restrict filename, const char * restrict mode, FILE * restrict stream);
#else
#if !defined(__cflow_processed) || defined(_uses_freopen_stdio_os1_h)
FILE *freopen(const char * restrict filename, const char * restrict mode, FILE * restrict stream)
{
#ifdef __cflow_processed
  #error "Not implemented yet"
#endif
} 
#endif
#endif // Has Main

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#if !defined(__cflow_processed) || defined(_uses_setbuf_stdio_os1_h)
inline void setbuf(FILE * restrict stream, char * restrict buf)
{
#ifdef __cflow_processed
  #error "Not implemented yet"
#endif
} 
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#if !defined(__cflow_processed) || defined(_uses_setvbuf_stdio_os1_h)
inline int setvbuf(FILE * restrict stream, char * restrict buf, int mode, size_t size)
{
#ifdef __cflow_processed
# error "Not implemented yet"
#endif
}
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

// The possibilities for the third argument to `fseek'.
// These values should not be changed!
#define SEEK_SET        0       
#define SEEK_CUR        1       
#define SEEK_END        2       


#if !defined(__cflow_processed) || defined(_uses__fsetpos_stdio_os1_h)
inline long _fsetpos(FILE *stream, fpos_t *pos, int whence)
{
        int sys_whence, retval;
        vector int sys_rval;

        asm("\n\t!! begin _fsetpos()");

        if( ! stream || ! stream->fd ) {
                errno = EBADF;
                return -1;
        }

        sys_whence = -1;
        where (whence == SEEK_SET)
                asm("$sys_setwhence(%0, $SYS_FSE_SET)\n" : "=r" (sys_whence));
        where (whence == SEEK_CUR)
                asm("$sys_setwhence(%0, $SYS_FSE_CUR)\n" : "=r" (sys_whence));
        where (whence == SEEK_END)
                asm("$sys_setwhence(%0, $SYS_FSE_END)\n" : "=r" (sys_whence));
        if (sys_whence < 0) {
                errno = EINVAL;
                return -1;
        }
        
        asm("\t$sys_fseek( 0.%0, 0.%1, %2 )\n"
            : : "r" (stream->fd), "r" (*pos), "r" (sys_whence));
        asm("\tlmtr %0 $MEM_SYS_RVAL\n" : "=r" (sys_rval));
        asm("\t!! end _fsetpos()\n");

        *pos = sys_rval.hi;
        retval = 0;
        where (sys_rval.lo) {
                stream->err = 1;
                errno = sys_rval.hi;
                retval = -1;
        }

        return retval;
}
#endif // fseek()


#if !defined(__cflow_processed) || defined(_uses_fseek_stdio_os1_h)
inline int fseek(FILE *stream, long offset, int whence)
{
        fpos_t pos = offset;
        return _fsetpos(stream, &pos, whence);
}
#endif // fseek()


#if !defined(__cflow_processed) || defined(_uses_rewind_stdio_os1_h)
inline void rewind(FILE *stream)
{
        fpos_t pos = 0;
        _fsetpos(stream, &pos, SEEK_SET);
}
#endif // rewind()


#if !defined(__cflow_processed) || defined(_uses_fsetpos_stdio_os1_h)
inline int fsetpos(FILE *stream, fpos_t *pos)
{
        return _fsetpos(stream, pos, SEEK_SET);
}
#endif // fsetpos()


#ifndef __HAS_MAIN
extern int fgetpos(FILE *stream, fpos_t *pos);
#else
#if !defined(__cflow_processed) || defined(_uses_fgetpos_stdio_os1_h)
int fgetpos(FILE *stream, fpos_t *pos)
{
        *pos = 0;
        return _fsetpos(stream, pos, SEEK_CUR);
}
#endif // fgetpos()
#endif // Has Main


#ifndef __HAS_MAIN
extern long ftell(FILE *stream);
#else
#if !defined(__cflow_processed) || defined(_uses_ftell_stdio_os1_h)
long ftell(FILE *stream) {
        fpos_t *pos = 0;
        long result;

        result = _fsetpos(stream, pos, SEEK_CUR);

        where (result == 0)
                result = *pos;

        return result;
}
#endif // ftell()
#endif // Has Main


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#define _fputs(str, stream, sep)                                        \
  int retval;                                                           \
  vector int sys_rval;                                                  \
                                                                        \
  if(! stream->fd) {                                                    \
    return EOF;                                                         \
  }                                                                     \
                                                                        \
  asm("\t$io_start\n"                                                   \
      "\t$io_fd( 0.%1 )\n"                                              \
      "\t\\equl $cmd    $SYS_IOCMD_GWR\n"                               \
      "\t\\equl $fmtsep <$SYS_IOFMT_VARSTR .or. %2>\n"                  \
      "\t\\equl $dev    $SYS_IODEV_MEM\n"                               \
      "\t\\equl $l      0\n"                                            \
      "\t\\equl $bs     $SYS_IOBS_V\n"                                  \
      "\t\\equl $rdflg  $SYS_IORDFLG_NOP\n"                             \
      "\t$io_packet($cmd, $fmtsep, $rdflg, $dev, $l, $bs, 0.%3)\n"      \
      "\t$io_end\n"                                                     \
      "\tlmtr %0 $MEM_SYS_RVAL\n"                                       \
      : "=r" (sys_rval) : "r" (stream->fd), "I" (sep), "r" (str));      \
                                                                        \
  retval = 0;                                                           \
  where (sys_rval.lo) {                                                 \
    retval = EOF;                                                       \
    stream->err = 1;                                                    \
    errno = sys_rval.hi;                                                \
  }                                                                     \
                                                                        \
  return retval;

#if !defined(__cflow_processed) || defined(_uses_fputs_stdio_os1_h)
inline int fputs(const char *str, FILE *stream)
{
  _fputs(str, stream, _SYS_IOPSEP_NOP)
}
#endif // fputs()

#if !defined(__cflow_processed) || defined(_uses_puts_stdio_os1_h)
inline int puts(const char *str)
{
  _fputs(str, stdout, _SYS_IOPSEP_NL)
}
#endif

#undef _fputs

#if !defined(__cflow_processed) || defined(_uses_fputc_stdio_os1_h)
inline int fputc(int c, FILE *stream)
{
  int buf[2], retval;

  buf[0] = c;
  buf[1] = 0;

  retval = fputs((char *) buf, stream);

  where (retval != EOF)
    retval = c;

  return retval;
}
#endif // fputc()


#define putc(C, STR) fputc(C, STR)


#if !defined(__cflow_processed) || defined(_uses_putchar_stdio_os1_h)
inline int putchar(int c)
{
  return putc(c,stdout);
}
#endif


// assert.h has to be include here
#include <assert.h>


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#ifndef __HAS_MAIN
extern size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
#else
#if !defined(__cflow_processed) || defined(_uses_fread_stdio_os1_h)
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)
{
        int retval, nbytes, nwords;
        vector int sys_rval;

        nbytes = size * nmemb;
        nwords = (nbytes >> 4);
        assert((nwords*16) == nbytes);

        asm("\t$io_start\n"
            "\t\\equl $cmd   $SYS_IOCMD_BRD\n"
            "\t\\equl $fmt   $SYS_IOFMT_BIN\n"
            "\t\\equl $sep   $SYS_IOPSEP_NOP\n"
            "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"
            "\t\\equl $dev   $SYS_IODEV_MEM\n"
            "\t\\equl $bs    $SYS_IOBS_V\n"
            "\t$io_fd( 0.%2 )\n"
            "\t$io_slice_all\n"
            "\t$io_packet($cmd, <$fmt .or. $sep>, $rdflg, $dev, 0.%1, $bs, 0.%3)\n"
            "\t$io_end\n"
            "\tlmtr %0 $MEM_SYS_RVAL\n"
            : "=r" (sys_rval) : "r" (nwords), "r" (stream->fd), "r" (ptr) );

        // check return code
        retval = nmemb;
        where (sys_rval.lo) {
                stream->err = 1;
                retval = 0;
        }

        return retval;
}
#endif // fread
#endif // Has Main


#ifndef __HAS_MAIN
extern size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
#else
#if !defined(__cflow_processed) || defined(_uses_fwrite_stdio_os1_h)
size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
{
        int retval, nbytes, nword;
        vector int sys_rval;

        nbytes = size * nmemb;
        assert( (nbytes%16)==0 );

            asm("\t$io_start\n"
                "\t\\equl $cmd   $SYS_IOCMD_GWR\n"
                "\t\\equl $fmt   $SYS_IOFMT_BIN\n"
                "\t\\equl $sep   $SYS_IOPSEP_NOP\n"
                "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"
                "\t\\equl $dev   $SYS_IODEV_MEM\n"
                "\t\\equl $l     %1>>4\n"
                "\t\\equl $bs    $SYS_IOBS_V\n"
                "\t$io_fd( 0.%2 )\n"
                "\t$io_slice_all\n"
                "\t$io_packet($cmd, <$fmt .or. $sep>, $rdflg, $dev, $l, $bs, 0.%3)\n"
                "\t$io_end\n"
                "\tlmtr %0 $MEM_SYS_RVAL\n"
                : "=r" (sys_rval) : "r" (nbytes), "r" (stream->fd), "r" (ptr) );

        // check OS1 return code
        retval = nmemb;
        where (sys_rval.lo) {
                stream->err = 1;
                retval = 0;
        }

        return retval;
}
#endif // fwrite()
#endif // Has Main


//------------------------------------------------------------------------------
// Non-standard functions
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#define tfread(PTR,NMEMB,STREAM) __tfread(__typecode(*PTR),PTR,NMEMB,STREAM)

#ifndef __HAS_MAIN
extern size_t __tfread(int tcode, const void *ptr, size_t nmemb, FILE *stream);
#else
#if !defined(__cflow_processed) || defined(_uses___tfread_stdio_os1_h)
size_t __tfread(int tcode, const void *ptr, size_t nmemb, FILE *stream)
{
  int retval;
  vector int sys_rval;


#define __iopacket(rdflg) \
    asm("\t$io_start\n" \
        "\t\\equl $cmd   $SYS_IOCMD_BRD\n" \
        "\t\\equl $fmt   $SYS_IOFMT_BIN\n" \
        "\t\\equl $sep   $SYS_IOPSEP_NOP\n" \
        "\t\\equl $rdflg %1\n" \
        "\t\\equl $dev   $SYS_IODEV_MEM\n" \
        "\t\\equl $l     0.%2\n" \
        "\t\\equl $bs    $SYS_IOBS_V\n" \
        "\t$io_fd( 0.%3 )\n" \
        "\t$io_slice_all\n" \
        "\t$io_packet($cmd, <$fmt .or. $sep>, $rdflg, $dev, $l, $bs, 0.%4)\n" \
        "\t$io_end\n" \
        "\tlmtr %0 $MEM_SYS_RVAL\n" \
        : "=r" (sys_rval) : "I" (rdflg), "r" (nmemb), "r" (stream->fd), "r" (ptr))

  if ((tcode==NLCC_FLOAT) || (tcode==NLCC_DOUBLE)) {
    __iopacket(_SYS_IORDFLG_HZERO);
  }
  else if ((tcode==NLCC_INT) || (tcode==NLCC_UNSIGNED)) {
    __iopacket(_SYS_IORDFLG_HMIRROR);
  }
  else if ((tcode==NLCC_COMPLEX) || (tcode==NLCC_VECTOR) || (tcode==NLCC_VFLOAT) ||
           (tcode==NLCC_VINT) || (tcode==NLCC_VUINT)) { 
    __iopacket(_SYS_IORDFLG_NOP);
  }
  else {
    assert(0);
  }

#undef __iopacket

  // check OS1 return code
  retval = nmemb;
  where (sys_rval.lo) {
    stream->err = 1;
    retval = 0;
  }

  return retval;
}
#endif // tfread
#endif // Has Main


#define tfwrite(PTR,NMEMB,STREAM) __tfwrite(__typecode(*PTR),PTR,NMEMB,STREAM)


#ifndef __HAS_MAIN
extern size_t __tfwrite(int tcode, const void *ptr, size_t nmemb, FILE *stream);
#else
#if !defined(__cflow_processed) || defined(_uses___tfwrite_stdio_os1_h)
size_t __tfwrite(int tcode, const void *ptr, size_t nmemb, FILE *stream)
{
        int retval;
        vector int sys_rval;

        if( (tcode==NLCC_FLOAT) || (tcode==NLCC_DOUBLE) || (tcode==NLCC_INT) || (tcode==NLCC_UNSIGNED) )
          {
            asm("\t$io_start\n"
                "\t\\equl $cmd   $SYS_IOCMD_GWR\n"
                "\t\\equl $fmt   $SYS_IOFMT_BIN\n"
                "\t\\equl $sep   $SYS_IOPSEP_NOP\n"
                "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"
                "\t\\equl $dev   $SYS_IODEV_MEM\n"
                "\t\\equl $l     0.%1\n"
                "\t\\equl $bs    $SYS_IOBS_L\n"
                "\t$io_fd( 0.%2 )\n"
                "\t$io_slice_all\n"
                "\t$io_packet($cmd, <$fmt .or. $sep>, $rdflg, $dev, $l, $bs, 0.%3)\n"
                "\t$io_end\n"
                "\tlmtr %0 $MEM_SYS_RVAL\n"
                : "=r" (sys_rval) : "r" (nmemb), "r" (stream->fd), "r" (ptr) );
          }
        else
        if( (tcode==NLCC_COMPLEX) || (tcode==NLCC_VECTOR) || (tcode==NLCC_VFLOAT) 
            || (tcode==NLCC_VINT) || (tcode==NLCC_VUINT) )
          { 
            asm("\t$io_start\n"
                "\t\\equl $cmd   $SYS_IOCMD_GWR\n"
                "\t\\equl $fmt   $SYS_IOFMT_BIN\n"
                "\t\\equl $sep   $SYS_IOPSEP_NOP\n"
                "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"
                "\t\\equl $dev   $SYS_IODEV_MEM\n"
                "\t\\equl $l     0.%1\n"
                "\t\\equl $bs    $SYS_IOBS_V\n"
                "\t$io_fd( 0.%2 )\n"
                "\t$io_slice_all\n"
                "\t$io_packet($cmd, <$fmt .or. $sep>, $rdflg, $dev, $l, $bs, 0.%3)\n"
                "\t$io_end\n"
                "\tlmtr %0 $MEM_SYS_RVAL\n"
                : "=r" (sys_rval) : "r" (nmemb), "r" (stream->fd), "r" (ptr) );
          }
        else
          {
            assert(0);
          }

        // check OS return code
        retval = nmemb;
        where (sys_rval.lo) {
                stream->err = 1;
                retval = 0;
        }

        return retval;
}
#endif // tfwrite
#endif // Has Main


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#define __IOPUT_INIT \
        int retval;\
        vector int sys_rval;\
\
        _Pragma("localmem");\
\

#define __IOPUT(ITYPE,CTYPE)    \
        asm("\n\t!! begin fput"#CTYPE"()");\
        asm("\t$io_start\n"\
            "\t$io_fd( 0.%1 )\n"\
            "\t$io_put"#ITYPE"( 0x0.%2 )\n"\
            "\t$io_end\n"\
            "\tlmtr %0 $MEM_SYS_RVAL\n"\
            : "=r" (sys_rval) : "r" (stream->fd), "r" (&val) );\
\
        retval = 0;\
        where (sys_rval.lo) {\
                stream->err = 1;\
                retval = -1;\
        }\
        asm("\t!! end fput"#CTYPE"()\n");\
        return retval

#define fputf(VAL,STREAM) fputd(VAL, STREAM)
#define putf(VAL,STREAM)  putd(VAL, STREAM)

#if !defined(__cflow_processed) || defined(_uses_fputd_stdio_os1_h)
inline int fputd(const double val, FILE *stream) { __IOPUT_INIT
__IOPUT(e,d); }
#endif // fputd()

#if !defined(__cflow_processed) || defined(_uses_putd_stdio_os1_h)
inline int putd(const double val) {  return fputd( val, stdout ); }
#endif

#if !defined(__cflow_processed) || defined(_uses_fputx_stdio_os1_h)
inline int fputx(const complex val, FILE *stream) { __IOPUT_INIT
__IOPUT(z,x); }
#endif // fputx()

#if !defined(__cflow_processed) || defined(_uses_putx_stdio_os1_h)
inline int putx(const complex val) { return fputx( val, stdout ); }
#endif

#if !defined(__cflow_processed) || defined(_uses_fputv_stdio_os1_h)
inline int fputv(const vector val, FILE *stream) { __IOPUT_INIT
__IOPUT(z,x); }
#endif // fputv()

#if !defined(__cflow_processed) || defined(_uses_putv_stdio_os1_h)
inline int putv(const vector val ) { return fputv( val, stdout ); }
#endif

#if !defined(__cflow_processed) || defined(_uses_fputi_stdio_os1_h)
inline int fputi(const int val, FILE *stream) { __IOPUT_INIT
__IOPUT(d,i); }
#endif // fputi()

#if !defined(__cflow_processed) || defined(_uses_puti_stdio_os1_h)
inline int puti(const int val) {  return fputi( val, stdout ); }
#endif

#if !defined(__cflow_processed) || defined(_uses_fputiv_stdio_os1_h)
inline int fputiv(const vector int val, FILE *stream) { __IOPUT_INIT
__IOPUT(dv,iv); }
#endif // fputiv()

#if !defined(__cflow_processed) || defined(_uses_putiv_stdio_os1_h)
inline int putiv(const vector int val) {  return fputiv( val, stdout ); }
#endif

#if !defined(__cflow_processed) || defined(_uses_fputh_stdio_os1_h)
inline int fputh( const int val, FILE *stream) { __IOPUT_INIT
__IOPUT(x,h); }
#endif // fputh()

#if !defined(__cflow_processed) || defined(_uses_fputhv_stdio_os1_h)
inline int fputhv(const int val, FILE *stream) { __IOPUT_INIT
__IOPUT(xv,hv); }
#endif // fputhv()

#if !defined(__cflow_processed) || defined(_uses_puth_stdio_os1_h)
inline int puth(const int val ) {  return fputh( val, stdout ); }
#endif

#if !defined(__cflow_processed) || defined(_uses_puthv_stdio_os1_h)
inline int puthv(const int val ) {  return fputhv( val, stdout ); }
#endif

#define __IOPUTA(CTS,ITYPE,BS)  \
        asm("\n\t!! begin fput"#CTS"a()");\
        asm("\t$io_start\n"\
            "\t$io_fd( 0.%1 )\n"\
            "\t\\equl $cmd   $SYS_IOCMD_GWR\n"\
            "\t\\equl $fmt   <$SYS_IOFMT_"#ITYPE">\n"\
            "\t\\equl $sep   <$SYS_IOPSEP_NL .or. $SYS_IOWSEP_SPACE>\n"\
            "\t\\equl $dev   $SYS_IODEV_MEM\n"\
            "\t\\equl $bs    "#BS"\n"\
            "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"\
            "\t$io_packet($cmd, <$fmt .or. $sep>, $rdflg, $dev, 0.%2, $bs, 0.%3)\n"\
            "\t$io_end\n"\
            "\tlmtr %0 $MEM_SYS_RVAL\n"\
            : "=r" (sys_rval)\
            : "r" (stream->fd), "r" (len), "r" (ptr) );\
\
        retval = 0;\
        where (sys_rval.lo) {\
                stream->err = 1;\
                retval = -1;\
        }\
        asm("\t!! end fput"#CTS"a()\n");\
        return retval

#if !defined(__cflow_processed) || defined(_uses_fputia_stdio_os1_h)
inline int fputia(const int *ptr, int len, FILE *stream) { __IOPUT_INIT __IOPUTA(i,INT,$SYS_IOBS_L); }
#endif // fputia()

#if !defined(__cflow_processed) || defined(_uses_fputiva_stdio_os1_h)
inline int fputiva(const int *ptr, int len, FILE *stream) { __IOPUT_INIT __IOPUTA(i,INT.or.$SYS_IOBSEP_SBRACKET,$SYS_IOBS_V); }
#endif // fputiva()

#if !defined(__cflow_processed) || defined(_uses_fputxa_stdio_os1_h)
inline int fputxa(const complex *ptr, int len,  FILE *stream) { __IOPUT_INIT __IOPUTA(x,DBL.or.$SYS_IOBSEP_RBRACKET,$SYS_IOBS_V); }
#endif // fputxa()

#if !defined(__cflow_processed) || defined(_uses_fputva_stdio_os1_h)
inline int fputva(const vector *ptr, int len,  FILE *stream) { __IOPUT_INIT __IOPUTA(x,DBL.or.$SYS_IOBSEP_RBRACKET,$SYS_IOBS_V); }
#endif // fputva()

#if !defined(__cflow_processed) || defined(_uses_fputda_stdio_os1_h)
inline int fputda( const double *ptr, int len,  FILE *stream) { __IOPUT_INIT __IOPUTA(d,DBL,$SYS_IOBS_L); }
#endif // fputda()

#if !defined(__cflow_processed) || defined(_uses_fputua_stdio_os1_h)
inline int fputua( const unsigned *ptr, int len,  FILE *stream) { __IOPUT_INIT __IOPUTA(u,UINT,$SYS_IOBS_L); }
#endif // fputua()

#if !defined(__cflow_processed) || defined(_uses_fputha_stdio_os1_h)
inline int fputha( const int *ptr, int len,  FILE *stream) { __IOPUT_INIT __IOPUTA(h,HEX,$SYS_IOBS_L); }
#endif // fputha()

#if !defined(__cflow_processed) || defined(_uses_fputhva_stdio_os1_h)
inline int fputhva( const int *ptr, int len,  FILE *stream) { __IOPUT_INIT __IOPUTA(h,HEX.or.$SYS_IOBSEP_SBRACKET,$SYS_IOBS_V); }
#endif // fputhva()

#if !defined(__cflow_processed) || defined(_uses_putia_stdio_os1_h)
inline int putia( const int *ptr, int len ) { return fputia( ptr, len, stdout ); }
#endif // putia()

#if !defined(__cflow_processed) || defined(_uses_putiva_stdio_os1_h)
inline int putiva( const int *ptr, int len ) { return fputiva( ptr, len, stdout ); }
#endif // putiva()

#if !defined(__cflow_processed) || defined(_uses_putxa_stdio_os1_h)
inline int putxa( const complex *ptr, int len ) { return fputxa( ptr, len, stdout ); }
#endif // putxa()

#if !defined(__cflow_processed) || defined(_uses_putva_stdio_os1_h)
inline int putva( const vector *ptr, int len ) { return fputva( ptr, len, stdout ); }
#endif // putva()

#if !defined(__cflow_processed) || defined(_uses_putda_stdio_os1_h)
inline int putda( const double *ptr, int len ) { return fputda( ptr, len, stdout ); }
#endif // putda()

#if !defined(__cflow_processed) || defined(_uses_putua_stdio_os1_h)
inline int putua( const unsigned *ptr, int len ) { return fputua( ptr, len, stdout ); }
#endif // putua()

#if !defined(__cflow_processed) || defined(_uses_putha_stdio_os1_h)
inline int putha( const int *ptr, int len ) { return fputha( ptr, len, stdout ); }
#endif // putha()

#if !defined(__cflow_processed) || defined(_uses_puthva_stdio_os1_h)
inline int puthva( const int *ptr, int len ) { return fputha( ptr, len, stdout ); }
#endif // puthva()


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#ifndef __HAS_MAIN

extern int fgetd( double *ptr, FILE *stream);
extern int getd( double *ptr );
extern int fgetx( complex *ptr, FILE *stream);
extern int getx( complex *ptr ) ;
extern int fgetv( vector *ptr, FILE *stream) ;
extern int getv( vector *ptr ) ;
extern int fgeti( int *ptr, FILE *stream) ;
extern int geti( int *ptr ) ;

#else
#define __IOGET(ITYPE,CTYPE)    \
        asm("\n\t!! begin fget"#CTYPE"()");\
        asm("\t$io_start\n"\
            "\t$io_fd( 0.%1 )\n"\
            "\t$io_slice_all\n"\
            "\t$io_get"#ITYPE"( 0.%2 )\n"\
            "\t$io_end\n"\
            "\tlmtr %0 $MEM_SYS_RVAL\n"\
            : "=r" (sys_rval) : "r" (stream->fd), "r" (ptr) );\
\
        retval = 0;\
        where (sys_rval.lo) {\
                stream->err = 1;\
                retval = -1;\
        }\
        asm("\t!! end fget"#CTYPE"()");\
        return retval

#if !defined(__cflow_processed) || defined(_uses_fgetd_stdio_os1_h)
int fgetd( double *ptr, FILE *stream) { __IOPUT_INIT
__IOGET(e,d); }
#endif // fgetd()

#if !defined(__cflow_processed) || defined(_uses_getd_stdio_os1_h)
int getd( double *ptr ) { return fgetd( ptr, stdin ); }
#endif // fgetd()

#if !defined(__cflow_processed) || defined(_uses_fgetx_stdio_os1_h)
int fgetx( complex *ptr, FILE *stream) { __IOPUT_INIT
__IOGET(z,x); }
#endif // fgetx()

#if !defined(__cflow_processed) || defined(_uses_getx_stdio_os1_h)
int getx( complex *ptr ) { return fgetx( ptr, stdin ); }
#endif // fgetx()

#if !defined(__cflow_processed) || defined(_uses_fgetv_stdio_os1_h)
int fgetv( vector *ptr, FILE *stream) { __IOPUT_INIT
__IOGET(z,x); }
#endif // fgetv()

#if !defined(__cflow_processed) || defined(_uses_getv_stdio_os1_h)
int getv( vector *ptr ) { return fgetv( ptr, stdin ); }
#endif // fgetv()

#if !defined(__cflow_processed) || defined(_uses_fgeti_stdio_os1_h)
int fgeti( int *ptr, FILE *stream) { __IOPUT_INIT
__IOGET(d,i); }
#endif // fgeti()

#if !defined(__cflow_processed) || defined(_uses_geti_stdio_os1_h)
int geti( int *ptr ) { return fgeti( ptr, stdin ); }
#endif // fgeti()

#endif // __HAS_MAIN

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#define printf(ARGS...) fprintf(stdout, ##ARGS)
#define vprintf(FMT, ARG) vfprintf(stdout, (FMT), (ARG))

#ifndef __HAS_MAIN
extern int fprintf(FILE *stream, const char *format, ...);
#else
#if !defined(__cflow_processed) || defined(_uses_fprintf_stdio_os1_h)
int fprintf(FILE *stream, const char *format, ...)
{
#pragma localmem

        int iocnt;
        vector int argcnt, sys_rval;
        va_list ap; 

        asm("\t!! begin fprintf()");

        if (!stream || !stream->fd) {
                errno = EBADF;
                return 0;
        }

        argcnt = __builtin_argcount();
        iocnt = argcnt.lo - 2;

        // output format string
        asm("\t$io_start\n"
            "\t$io_fd( 0.%0 )\n"
            "\t$io_cnt_set( %2 )\n"
            "\t\\equl $cmd   $SYS_IOCMD_PRF\n"
            "\t\\equl $fmt   $SYS_IOFMT_VARSTR\n"
            "\t\\equl $sep   <$SYS_IOPSEP_NOP .or. $SYS_IOWSEP_SPACE>\n"
            "\t\\equl $dev   $SYS_IODEV_MEM\n"
            "\t\\equl $bs    $SYS_IOBS_V\n"
            "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"
            "\t$io_packet($cmd, <$fmt .or. $sep>, $rdflg, $dev, 0, $bs, 0.%1)\n"
            : : "r" (stream->fd), "r" (format), "r" (iocnt) );

        asm("\t$io_setloopflg\n");

        va_start(ap, format); 
        for( ; iocnt > 0; iocnt-- ) {
                vector int arginfo = _va_info(ap);
                void *ptr = _va_ptr(ap);
                _va_skip( ap, arginfo.lo );
                if( arginfo.hi == NLCC_STRING ) {
                        char *str = *(char **)ptr;
                        asm("\t$io_cnt_decr\n"
                            "\t\\equl $cmd   $SYS_IOCMD_PRF\n"
                            "\t\\equl $fmt   $SYS_IOFMT_VARSTR\n"
                            "\t\\equl $sep   <$SYS_IOPSEP_NOP .or. $SYS_IOWSEP_NOP>\n"
                            "\t\\equl $dev   $SYS_IODEV_MEM\n"
                            "\t\\equl $bs    $SYS_IOBS_V\n"
                            "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"
                            "\t$io_packet($cmd, <$fmt .or. $sep>, $rdflg, $dev, 0, $bs, 0.%0)\n"
                            : :  "r" (str) );
                } else {
                        asm("\t$io_cnt_decr\n"
                            "\t\\equl $cmd   $SYS_IOCMD_PRF\n"
                            "\t\\equl $fmt   $SYS_IOFMT_BIN\n"
                            "\t\\equl $sep   <$SYS_IOPSEP_NOP .or. $SYS_IOWSEP_NOP>\n"
                            "\t\\equl $dev   $SYS_IODEV_MEM\n"
                            "\t\\equl $l     0.%1\n"
                            "\t\\equl $bs    $SYS_IOBS_V\n"
                            "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"
                            "\t$io_packet($cmd, <$fmt .or. $sep>, $rdflg, $dev, $l, $bs, 0.%0)\n"
                            : :  "r" (ptr), "r" (arginfo.lo) );
                }
        }
        va_end(ap);

        asm("\t$io_cnt_clear\n"
            "\t$io_end\n"
            "\tlmtr %0 $MEM_SYS_RVAL\n"
            "\t!! end fprintf()\n"
            : "=r" (sys_rval));

        where (sys_rval.lo)
                stream->err = 1;

        asm("\t!! end fprintf()");

        return (int) (sys_rval.hi);
}
#endif // fprintf()
#endif // Has Main


#ifndef __HAS_MAIN
extern int vfprintf(FILE * restrict stream, const char * restrict format, va_list ap);
#else
#if !defined(__cflow_processed) || defined(_uses_vfprintf_stdio_os1_h)
int vfprintf(FILE * restrict stream, const char * restrict format, va_list ap) {
        int n_args, argc;
        vector int sys_rval;

        asm("\t!! begin vfprintf()");
        #pragma localmem
        n_args = _va_args(ap);

        if( ! stream->fd ) { 
                errno = EBADF;
                return 0;
        }

        // output format string
        asm("\t$io_start\n"
            "\t$io_fd( 0.%0 )\n"
            "\t$io_cnt_set( %2 )\n"
            "\t\\equl $cmd   $SYS_IOCMD_PRF\n"
            "\t\\equl $fmt   $SYS_IOFMT_VARSTR\n"
            "\t\\equl $sep   <$SYS_IOPSEP_NOP .or. $SYS_IOWSEP_SPACE>\n"
            "\t\\equl $dev   $SYS_IODEV_MEM\n"
            "\t\\equl $bs    $SYS_IOBS_V\n"
            "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"
            "\t$io_packet($cmd, <$fmt .or. $sep>, $rdflg, $dev, 0, $bs, 0.%1)"
            : : "r" (stream->fd), "r" (format), "r" (n_args) );

        for( ; n_args > 0; n_args -- ) {
                vector int arginfo = _va_info(ap);
                void *ptr = _va_ptr(ap);
                _va_skip( ap, arginfo.lo );
                if( arginfo.hi == NLCC_STRING ) {
                        char *str = *(char **)ptr;
                        asm("\t$io_cnt_decr\n"
                            "\t\\equl $cmd   $SYS_IOCMD_PRF\n"
                            "\t\\equl $fmt   $SYS_IOFMT_VARSTR\n"
                            "\t\\equl $sep   <$SYS_IOPSEP_NOP .or. $SYS_IOWSEP_NOP>\n"
                            "\t\\equl $dev   $SYS_IODEV_MEM\n"
                            "\t\\equl $bs    $SYS_IOBS_V\n"
                            "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"
                            "\t$io_packet($cmd, <$fmt .or. $sep>, $rdflg, $dev, 0, $bs, 0.%0)\n"
                            : :  "r" (str) );
                } else {
                        asm("\t$io_cnt_decr\n"
                            "\t\\equl $cmd   $SYS_IOCMD_PRF\n"
                            "\t\\equl $fmt   $SYS_IOFMT_BIN\n"
                            "\t\\equl $sep   <$SYS_IOPSEP_NOP .or. $SYS_IOWSEP_NOP>\n"
                            "\t\\equl $dev   $SYS_IODEV_MEM\n"
                            "\t\\equl $l     0.%1\n"
                            "\t\\equl $bs    $SYS_IOBS_V\n"
                            "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"
                            "\t$io_packet($cmd, <$fmt .or. $sep>, $rdflg, $dev, $l, $bs, 0.%0)\n"
                            : :  "r" (ptr), "r" (arginfo.lo) );
                }
        }
        asm("\t$io_cnt_clear\n"
            "\t$io_end\n"
            "\t!! end vfprintf()\n"
            "\tlmtr %0 $MEM_SYS_RVAL\n"
            : "=r" (sys_rval));

        where (sys_rval.lo)
                stream->err = 1;

        asm("\t!! end vfprintf()");

        return (int) (sys_rval.hi);
}
#endif // vfprintf()
#endif // Has Main


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#define scanf(ARGS...) fscanf(stdin, ##ARGS)

#ifndef __HAS_MAIN
extern int fscanf(FILE * restrict stream, const char * restrict format, ...);
#else
#if !defined(__cflow_processed) || defined(_uses_fscanf_stdio_os1_h)
int fscanf(FILE * restrict stream, const char * restrict format, ...)
{
        int iocnt;
        int n_args, argc;
        vector int argcnt, sys_rval;
        va_list ap;

        if(! stream || stream->mode == _SYS_IOMODE_CLOSED) {
                errno = EBADF;
                return 0;
        }

        asm("\t!! begin fscanf()");
        #pragma localmem
        argcnt = __builtin_argcount();
        iocnt = argcnt.lo - 2;

        // output format string
        asm("\t$io_start\n"
            "\t$io_fd( 0.%0 )\n"
            "\t$io_cnt_set( %2 )\n"
            "\t\\equl $cmd   $SYS_IOCMD_SCF\n"
            "\t\\equl $fmt   $SYS_IOFMT_VARSTR\n"
            "\t\\equl $dev   $SYS_IODEV_MEM\n"
            "\t\\equl $bs    $SYS_IOBS_V\n"
            "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"
            "\t$io_packet($cmd, $fmt, $rdflg, $dev, 0, $bs, 0.%1)"
            : : "r" (stream->fd), "r" (format), "r" (iocnt) );

        va_start(ap, format);
        for( ; iocnt > 0; iocnt -- ) {
                int size = _va_info(ap);
                void *ptr = *(void**) (_va_ptr(ap));
                _va_skip( ap, size );
                asm("\t$io_cnt_decr\n"
                    "\t\\equl $cmd   $SYS_IOCMD_SCF\n"
                    "\t\\equl $fmt   $SYS_IOFMT_BIN\n"
                    "\t\\equl $dev   $SYS_IODEV_MEM\n"
                    "\t\\equl $l     1\n"
                    "\t\\equl $bs    $SYS_IOBS_V\n"
                    "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"
                    "\t$io_packet($cmd, $fmt, $rdflg, $dev, $l, $bs, 0.%0)"
                    : :  "r" (ptr) );
        }
        va_end(ap);
        asm("\t$io_cnt_clear\n"
            "\t$io_end\n"
            "\t!! end fscanf()\n"
            "\tlmtr %0 $MEM_SYS_RVAL\n"
            : "=r" (sys_rval));

        where (sys_rval.lo)
                stream->err = 1;

        return (int) (sys_rval.hi);
}
#endif
#endif // Has Main


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#ifndef __HAS_MAIN
extern void clearerr(FILE *stream);
#else
#if !defined(__cflow_processed) || defined(_uses_clearerr_stdio_os1_h)
void clearerr(FILE *stream)
{
  stream->err = 0;
}
#endif
#endif // Has Main


#ifndef __HAS_MAIN
extern int feof(FILE *stream);
#else
#if !defined(__cflow_processed) || defined(_uses_feof_stdio_os1_h)
int feof(FILE *stream)
{
  vector int sys_rval;
  int ret;

  if( ! stream || ! stream->fd ) {
    errno = EBADF;
    return EOF;
  }

  asm("\t$io_start\n"
      "\t$io_fd(0.%1)"
      "\t$io_feof($SYS_IODEV_MEM, 0.%2)"
      "\t$io_end\n"
      "\tlmtr %0 $MEM_SYS_RVAL\n"
      : "=r" (sys_rval) : "r" (stream->fd), "r" (&ret));

  where (ret != 0 || sys_rval.hi != 0)
    ret = EOF;

  return ret;
}
#endif
#endif // Has Main


#ifndef __HAS_MAIN
extern inline int ferror(FILE *stream);
#else
#if !defined(__cflow_processed) || defined(_uses_ferror_stdio_os1_h)
inline int ferror(FILE *stream)
{
  return stream->err;
}
#endif
#endif // Has Main


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#ifndef __HAS_MAIN
extern void perror(const char *s);
#else
#if !defined(__cflow_processed) || defined(_uses_perror_stdio_os1_h)
void perror(const char *s)
{
        if( s && s[0] ) { 
                fputs(s,stderr);
                fputs(": ",stderr);
        }
        fputs(strerror(errno),stderr);
        fputs("\n",stderr);
}
#endif // perror()
#endif // Has Main


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#if !defined(__cflow_processed) || defined(_uses_fileno_stdio_os1_h)
inline int fileno(FILE *stream)
{
  return stream->fd;
}
#endif // fileno()


//------------------------------------------------------------------------------
// OS1 multidata functions
//------------------------------------------------------------------------------

#include <os1/slice_stdio_os1.h>

#endif /* _NLIBC_OS1_STDIO_H */

---