slice_stdio_os1.h

Go to the documentation of this file.

/* =============
 * apeNEXT/nlibc
 * =============
 *
 * apeNEXT multidata stdio
 *
 * $Id: slice_stdio_os1.h,v 1.20 2006/05/06 14:42:24 pleiter Exp $
 *----------------------------------------------------------------------------------------------- */
#ifndef _NLIBC_OS1_SLICE_STDIO_H
#define _NLIBC_OS1_SLICE_STDIO_H

#include <nlibc.h>

#include <stdarg.h>             // for va_list etc.
#include <os1/defs_os1.h>       // for SYS_IOFMT_*

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

/*--------------------------------------------------------------------------------------------------
/!
\par NAME
  mfputi, mfputx, mfputd,                                                                       \n
  mfputu, mputi, mputx, mputd,                                                                  \n
  mputu - formatted output of int, complex, double and unsigned                                 \n
  from specified node(s)                                                                        \n

\par SYNOPSIS
  #include <stdio.h>                                                                            \n
                                                                                                \n
  mfputi(int x1, int y1, int z1, [ int x2, int y2, int z2, ] int value, FILE *stream)           \n
  mfputx(int x1, int y1, int z1, [ int x2, int y2, int z2, ] complex value, FILE *stream)       \n
  mfputd(int x1, int y1, int z1, [ int x2, int y2, int z2, ] double value, FILE *stream)        \n
  mfputu(int x1, int y1, int z1, [ int x2, int y2, int z2, ] unsigned value, FILE *stream)      \n
  mputi(int x1, int y1, int z1, [ int x2, int y2, int z2, ] int value)                          \n
  mputx(int x1, int y1, int z1, [ int x2, int y2, int z2, ] complex value)                      \n
  mputd(int x1, int y1, int z1, [ int x2, int y2, int z2, ] double value)                       \n
  mputu(int x1, int y1, int z1, [ int x2, int y2, int z2, ] unsigned value)

\par DESCRIPTION
  The functions produce formatted output of their value argument on the specified stream (fput
  variants) or on stdout (put variants). The format used is defined by nose. The specification
  of the second coordinate triple is optional.  If present, it specifies the 'upper' corner of
  a slice of nodes.  If not present, the first triple specifies coordinates of a single
  node.

\par RETURN VALUE
  Number of written words
*/
//--------------------------------------------------------------------------------------------------

#define __MIOPUT(ITS, CTS, CTYPE, STREAM) \
        va_list ap;\
        int n_args;\
        int x2 = x1, y2 = y1, z2 = z1;\
        CTYPE value;\
        vector int sys_retval;\
        int fput_retval;\
        FILE *stream;\
\
        asm("\n\t!! begin mfput"#CTS"()");\
        va_start( ap, z1 );\
\
        n_args = __builtin_argcount();\
        if( n_args >= 6 ) {\
                x2 = va_arg(ap, int);\
                y2 = va_arg(ap, int);\
                z2 = va_arg(ap, int);\
        }\
\
        value = va_arg(ap,CTYPE);\
        stream = STREAM;\
\
        asm("\t$io_start\n"\
            "\t$io_fd( 0.%1 )\n"\
            "\t$io_slice(0.%2,0.%3,0.%4,0.%5,0.%6,0.%7)\n"\
            "\t$io_put"#ITS"( 0x0.%8 )\n"\
            "\t$io_end\n"\
            "\tlmtr %0 $MEM_SYS_RVAL\n"\
            : "=r" (sys_retval)\
            : "r" (stream->fd),\
              "r" (x1),  "r" (y1),  "r" (z1),  "r" (x2),  "r" (y2),  "r" (z2), \
              "r" (&value) );\
\
        fput_retval = (sys_retval.lo) ? -1 : 0;\
        asm("\t!! end mfput"#CTS"()");\
        return fput_retval

#ifdef __HAS_MAIN
#define BODY(args) args
#else
#define BODY(args) ;
#endif

#if !defined(__cflow_processed) || defined(_uses_mfputi_slice_stdio_os1_h)
int mfputi( int x1, int y1, int z1, ... ) BODY({ __MIOPUT(d,i,int,(va_arg(ap, FILE*))); })
#endif // mfputi()

#if !defined(__cflow_processed) || defined(_uses_mputi_slice_stdio_os1_h)
int mputi( int x1, int y1, int z1, ... ) BODY({ __MIOPUT(d,i,int,stdout); })
#endif // mfputi()

#if !defined(__cflow_processed) || defined(_uses_mfputiv_slice_stdio_os1_h)
int mfputiv( int x1, int y1, int z1, ... ) BODY({ __MIOPUT(dv,iv,int,(va_arg(ap, FILE*))); })
#endif // mfputiv()

#if !defined(__cflow_processed) || defined(_uses_mputiv_slice_stdio_os1_h)
int mputiv( int x1, int y1, int z1, ... ) BODY({ __MIOPUT(dv,iv,int,stdout); })
#endif // mfputiv()

#if !defined(__cflow_processed) || defined(_uses_mfputx_slice_stdio_os1_h)
int mfputx( int x1, int y1, int z1, ... ) BODY({ __MIOPUT(z,x,complex,(va_arg(ap, FILE*))); })
#endif // mfputx()

#if !defined(__cflow_processed) || defined(_uses_mputx_slice_stdio_os1_h)
int mputx( int x1, int y1, int z1, ... ) BODY({ __MIOPUT(z,x,complex,stdout); })
#endif // mputx()

#if !defined(__cflow_processed) || defined(_uses_mfputd_slice_stdio_os1_h)
int mfputd( int x1, int y1, int z1, ... ) BODY({ __MIOPUT(e,d,double,(va_arg(ap, FILE*))); })
#endif // mfputd()

#if !defined(__cflow_processed) || defined(_uses_mputd_slice_stdio_os1_h)
int mputd( int x1, int y1, int z1, ... ) BODY({ __MIOPUT(e,d,double,stdout); })
#endif // mputd()

#if !defined(__cflow_processed) || defined(_uses_mfputu_slice_stdio_os1_h)
int mfputu( int x1, int y1, int z1, ... ) BODY({ __MIOPUT(x,u,unsigned,(va_arg(ap, FILE*))); })
#endif // mfputu()

#if !defined(__cflow_processed) || defined(_uses_mputu_slice_stdio_os1_h)
int mputu( int x1, int y1, int z1, ... ) BODY({ __MIOPUT(x,u,unsigned,stdout); })
#endif // mputu()

#if !defined(__cflow_processed) || defined(_uses_mfputh_slice_stdio_os1_h)
int mfputh( int x1, int y1, int z1, ... ) BODY({ __MIOPUT(x,u,unsigned,(va_arg(ap, FILE*))); })
#endif // mfputh()

#if !defined(__cflow_processed) || defined(_uses_mputh_slice_stdio_os1_h)
int mputh( int x1, int y1, int z1, ... ) BODY({ __MIOPUT(x,u,unsigned,stdout); })
#endif // mputh()

#if !defined(__cflow_processed) || defined(_uses_mfputhv_slice_stdio_os1_h)
int mfputhv( int x1, int y1, int z1, ... ) BODY({ __MIOPUT(xv,u,unsigned,(va_arg(ap, FILE*))); })
#endif // mfputhv()

#if !defined(__cflow_processed) || defined(_uses_mputhv_slice_stdio_os1_h)
int mputhv( int x1, int y1, int z1, ... ) BODY({ __MIOPUT(xv,u,unsigned,stdout); })
#endif // mputhv()

#define __MIOPUTA(ITS, ITYPE, CTS, CTYPE, BS,STREAM) \
        va_list ap;\
        int n_args;\
        int x2 = x1, y2 = y1, z2 = z1;\
        CTYPE *ptr;\
        int size;\
        vector int sys_retval;\
        int fput_retval;\
        FILE *stream;\
\
        asm("\n\t!! begin mfput"#CTS"a()");\
        va_start( ap, z1 );\
\
        n_args = __builtin_argcount();\
        if( n_args >= 7 ) {\
                x2 = va_arg(ap, int);\
                y2 = va_arg(ap, int);\
                z2 = va_arg(ap, int);\
        }\
\
        ptr = va_arg(ap,CTYPE *);\
        size= va_arg(ap,int);\
        stream = STREAM;\
\
        asm("\t$io_start\n"\
            "\t$io_fd( 0.%1 )\n"\
            "\t$io_slice(0.%2,0.%3,0.%4,0.%5,0.%6,0.%7)\n"\
            "\t\\equ $cmd   $SYS_IOCMD_SWR\n"\
            "\t\\equ $fmt   <$SYS_IOFMT_"#ITYPE">\n"\
            "\t\\equ $bs    "#BS"\n"\
            "\t\\equ $sep   <$SYS_IOPSEP_NL .or. $SYS_IOWSEP_SPACE>\n"\
            "\t$io_packet($cmd, <$fmt .or. $sep>, $SYS_IORDFLG_NOP, $SYS_IODEV_MEM, 0.%9, $bs, 0.%8)\n"\
            "\t$io_end\n"\
            "\tlmtr %0 $MEM_SYS_RVAL\n"\
            : "=r" (sys_retval)\
            : "r" (stream->fd),\
              "r" (x1),  "r" (y1),  "r" (z1),  "r" (x2),  "r" (y2),  "r" (z2), \
              "r" (ptr), "r" (size) );\
\
        fput_retval = (sys_retval.lo) ? -1 : 0;\
        asm("\t!! end mfput"#CTS"a()");\
        return fput_retval

#if !defined(__cflow_processed) || defined(_uses_mfputia_slice_stdio_os1_h)
int mfputia( int x1, int y1, int z1, ... ) BODY({ __MIOPUTA(d,INT,i,int,$SYS_IOBS_L,(va_arg(ap, FILE*))); })
#endif // mfputi()

#if !defined(__cflow_processed) || defined(_uses_mputia_slice_stdio_os1_h)
int mputia( int x1, int y1, int z1, ... ) BODY({ __MIOPUTA(d,INT,i,int,$SYS_IOBS_L,stdout); })
#endif // mputi()

#if !defined(__cflow_processed) || defined(_uses_mfputxa_slice_stdio_os1_h)
int mfputxa( int x1, int y1, int z1, ... ) BODY({ __MIOPUTA(z,DBL.or.$SYS_IOBSEP_RBRACKET,x,complex,$SYS_IOBS_V,(va_arg(ap, FILE*))); })
#endif // mputxa()

#if !defined(__cflow_processed) || defined(_uses_mputxa_slice_stdio_os1_h)
int mputxa( int x1, int y1, int z1, ... ) BODY({ __MIOPUTA(z,DBL.or.$SYS_IOBSEP_RBRACKET,x,complex,$SYS_IOBS_V,stdout); })
#endif // mputxa()

#if !defined(__cflow_processed) || defined(_uses_mfputda_slice_stdio_os1_h)
int mfputda( int x1, int y1, int z1, ... ) BODY({ __MIOPUTA(e,DBL,d,double,$SYS_IOBS_L,(va_arg(ap, FILE*))); })
#endif // mfputd()

#if !defined(__cflow_processed) || defined(_uses_mputda_slice_stdio_os1_h)
int mputda( int x1, int y1, int z1, ... ) BODY({ __MIOPUTA(e,DBL,d,double,$SYS_IOBS_L,stdout); })
#endif // mputd()

#if !defined(__cflow_processed) || defined(_uses_mfputva_slice_stdio_os1_h)
int mfputva( int x1, int y1, int z1, ... ) BODY({ __MIOPUTA(z,DBL.or.$SYS_IOBSEP_RBRACKET,v,vector,$SYS_IOBS_V,(va_arg(ap, FILE*))); })
#endif // mputva()

#if !defined(__cflow_processed) || defined(_uses_mputva_slice_stdio_os1_h)
int mputva( int x1, int y1, int z1, ... ) BODY({ __MIOPUTA(z,DBL.or.$SYS_IOBSEP_RBRACKET,v,vector,$SYS_IOBS_V,stdout); })
#endif // mputva()

/*--------------------------------------------------------------------------------------------------
/!
\par NAME
  mfgeti, mfgetx, mfgetd,
  mfgetu, mgeti, mgetx, mgetd,
  mgetu - formatted outget of int, complex, double and unsigned from specified node(s)

\par SYNOPSIS
  #include <stdio.h>                                                                            \n
                                                                                                \n
  mfgeti(int x1, int y1, int z1, [ int x2, int y2, int z2, ] int *ptr, FILE *stream)            \n
  mfgetx(int x1, int y1, int z1, [ int x2, int y2, int z2, ] complex *ptr, FILE *stream)        \n
  mfgetd(int x1, int y1, int z1, [ int x2, int y2, int z2, ] double *ptr, FILE *stream)         \n
  mfgetu(int x1, int y1, int z1, [ int x2, int y2, int z2, ] unsigned *ptr, FILE *stream)       \n
  mgeti(int x1, int y1, int z1, [ int x2, int y2, int z2, ] int *ptr)                           \n
  mgetx(int x1, int y1, int z1, [ int x2, int y2, int z2, ] complex *ptr)                       \n
  mgetd(int x1, int y1, int z1, [ int x2, int y2, int z2, ] double *ptr)                        \n
  mgetu(int x1, int y1, int z1, [ int x2, int y2, int z2, ] unsigned *ptr)

\par RETURN VALUE
  Number of written words
*/
//------------------------------------------------------------------------------

#define __MIOGET(ITS, CTS, CTYPE, STREAM) \
        va_list ap;\
        int n_args;\
        int x2 = x1, y2 = y1, z2 = z1;\
        CTYPE *ptr;\
        vector int sys_retval;\
        int fput_retval;\
        FILE *stream;\
\
        asm("\n\t!! begin mfput"#CTS"()");\
        va_start( ap, z1 );\
\
        n_args = __builtin_argcount();\
        if( n_args >= 6 ) {\
                x2 = va_arg(ap, int);\
                y2 = va_arg(ap, int);\
                z2 = va_arg(ap, int);\
        }\
\
        ptr = va_arg(ap, CTYPE *);\
        stream = STREAM;\
\
        asm("\t$io_start\n"\
            "\t$io_fd( 0.%1 )\n"\
            "\t$io_slice(0.%2,0.%3,0.%4,0.%5,0.%6,0.%7)\n"\
            "\t$io_get"#ITS"( 0.%8 )\n"\
            "\t$io_end\n"\
            "\tlmtr %0 $MEM_SYS_RVAL\n"\
            : "=r" (sys_retval)\
            : "r" (stream->fd),\
              "r" (x1),  "r" (y1),  "r" (z1),  "r" (x2),  "r" (y2),  "r" (z2), \
              "r" (ptr) );\
\
        fput_retval = (sys_retval.lo) ? -1 : 0;\
        asm("\t!! end mfput"#CTS"()");\
        return fput_retval

#if !defined(__cflow_processed) || defined(_uses_mfgeti_slice_stdio_os1_h)
int mfgeti( int x1, int y1, int z1, ... ) BODY({ __MIOGET(d,i,int,(va_arg(ap, FILE*))); })
#endif // mfgeti()

#if !defined(__cflow_processed) || defined(_uses_mfgetx_slice_stdio_os1_h)
int mfgetx( int x1, int y1, int z1, ... ) BODY({ __MIOGET(z,x,complex,(va_arg(ap, FILE*))); })
#endif // mfgetx()

#if !defined(__cflow_processed) || defined(_uses_mfgetdi_slice_stdio_os1_h)
int mfgetdi( int x1, int y1, int z1, ... ) BODY({ __MIOGET(e,d,double,(va_arg(ap, FILE*))); })
#endif // mfgetdi()

#undef BODY

//-----------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define mprintf(ARGS...) mfprintf(stdout, ##ARGS)

#ifndef __HAS_MAIN
extern int mfprintf(FILE *stream, int x1, int y1, int z1, ...);
#else
#if !defined(__cflow_processed) || defined(_uses_mfprintf_slice_stdio_os1_h)
int mfprintf(FILE *stream, int x1, int y1, int z1, ...)
{
#pragma localmem

  int         iocnt;
  vector int  argcnt, arginfo, sys_retval;
  va_list     ap; 
  int         x2 = x1, y2 = y1, z2 = z1;
  char        *format;

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

  va_start(ap, z1);

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

  if (iocnt < 0) {                      // insufficient number of arguments
    errno = EINVAL;
    return 0;
  }

  // check if more node coordinates follow
  // by testing the argument type 
  //   if 'int' : read 3 more coords
  //   else     : assume it's the 'format' arg.
  { va_list     ap2; 
    vector int  arginfo; 
    void        *ptr = _va_ptr(ap2);

    va_copy(ap2, ap);
    arginfo = _va_info(ap2);
    if (arginfo.hi == NLCC_INT) {
      x2 = va_arg(ap, int);
      y2 = va_arg(ap, int);
      z2 = va_arg(ap, int);
      iocnt -= 3;
    }
  }

  format = va_arg(ap, char *);

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

  // set file descriptor, slice and output format string
  asm("\t$io_start\n"
      "\t$io_fd(0.%0)\n"
      "\t$io_slice(0.%3, 0.%4, 0.%5, 0.%6, 0.%7, 0.%8)\n"\
      "\t$io_cnt_set(%2)\n"
      "\t\\equ $cmd   $SYS_IOCMD_SPRF\n"
      "\t\\equ $fmt   $SYS_IOFMT_VARSTR\n"
      "\t\\equ $dev   $SYS_IODEV_MEM\n"
      "\t\\equ $bs    $SYS_IOBS_V\n"
      "\t\\equ $rdflg $SYS_IORDFLG_NOP\n"
      "\t$io_packet($cmd, $fmt, $rdflg, $dev, 0, $bs, 0.%1 )"
      : : "r" (stream->fd), "r" (format), "r" (iocnt),
          "r" (x1), "r" (y1), "r" (z1), 
          "r" (x2), "r" (y2), "r" (z2));

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

  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\\equ $cmd   $SYS_IOCMD_SPRF\n"
          "\t\\equ $fmt   $SYS_IOFMT_VARSTR\n"
          "\t\\equ $sep   <$SYS_IOPSEP_NOP .or. $SYS_IOWSEP_NOP>\n"
          "\t\\equ $dev   $SYS_IODEV_MEM\n"
          "\t\\equ $bs    $SYS_IOBS_V\n"
          "\t\\equ $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\\equ $cmd   $SYS_IOCMD_SPRF\n"
          "\t\\equ $fmt   $SYS_IOFMT_BIN\n"
          "\t\\equ $sep   <$SYS_IOPSEP_NOP .or. $SYS_IOWSEP_NOP>\n"
          "\t\\equ $dev   $SYS_IODEV_MEM\n"
          "\t\\equ $l     0.%1\n"
          "\t\\equ $bs    $SYS_IOBS_V\n"
          "\t\\equ $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"
      "\t!! end mfprintf()\n"
      "\tlmtr %0 $MEM_SYS_RVAL\n"
      : "=r" (sys_retval) );

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

#define mvprintf(ARGS...) mvfprintf(stdout, ##ARGS)

#ifndef __HAS_MAIN
extern int mvfprintf(FILE *stream, int x1, int y1, int z1, ... );
#else
#if !defined(__cflow_processed) || defined(_uses_mvfprintf_slice_stdio_os1_h)
int mvfprintf(FILE *stream, int x1, int y1, int z1, ... )
{
#pragma localmem
        int n_args, n_pargs;
        vector int sys_retval;
        va_list ap, ap2, ap3; 
        int x2 = x1, y2 = y1, z2 = z1;
        char *format;

        va_start( ap, z1 );

        n_args = __builtin_argcount();
        n_pargs = n_args;
        // function expects at 5 or 8 arguments

        printf("n_args: %d\n",n_args);

        if( (n_args != 6) && (n_args !=9) ) 
        {
            return(0);
        }
        else
        {
        
            // check if more node coordinates follow
            // by testing the argument type 
            //  if 'int' : read 3 more coords
            //   else    : assume it's the 'format' arg.
            {   
                va_list ap2; 
                vector int arginfo; 
                void *ptr = _va_ptr(ap2);
                
                va_copy(ap2,ap);
                arginfo = _va_info(ap2);
                if( arginfo.hi == NLCC_INT ) {
                    x2 = va_arg(ap, int);
                    y2 = va_arg(ap, int);
                    z2 = va_arg(ap, int);
                    n_pargs -= 8;
                } else
                    n_pargs -= 5;
            }

            printf("n_pargs: %d\n",n_pargs);
            
            format = va_arg(ap, char *);
            
            va_copy(ap3,(va_list)va_arg(ap, va_list));
            
            n_pargs=_va_args(ap3);
            
            if( ! stream->fd ) { 
                errno = EBADF;
                return 0;
            }

            asm("\t!! begin mvfprintf()\n");
            
            // output format string
            asm("\t$io_start\n"
                "\t$io_fd( 0.%0 )\n"
                "\t$io_slice(0.%3,0.%4,0.%5,0.%6,0.%7,0.%8)\n"\
                "\t$io_cnt_set( %2 )\n"
                "\t\\equ $cmd   $SYS_IOCMD_SPRF\n"
                "\t\\equ $fmt   $SYS_IOFMT_VARSTR\n"
                "\t\\equ $sep   <$SYS_IOPSEP_NOP .or. $SYS_IOWSEP_SPACE>\n"
                "\t\\equ $dev   $SYS_IODEV_MEM\n"
                "\t\\equ $bs    $SYS_IOBS_V\n"
                "\t\\equ $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_pargs),
                "r" (x1), "r" (y1), "r" (z1), 
                "r" (x2), "r" (y2), "r" (z2));
            
            for(; n_pargs > 0; n_pargs -- ) {
                vector int arginfo = _va_info(ap3);
                void *ptr = _va_ptr(ap3);
                _va_skip( ap3, arginfo.lo );
                if( arginfo.hi == NLCC_STRING ) {
                    char *str = *(char **)ptr;
                    asm("\t$io_cnt_decr\n"
                        "\t\\equ $cmd   $SYS_IOCMD_SPRF\n"
                        "\t\\equ $fmt   $SYS_IOFMT_VARSTR\n"
                        "\t\\equ $sep   <$SYS_IOPSEP_NOP .or. $SYS_IOWSEP_NOP>\n"
                        "\t\\equ $dev   $SYS_IODEV_MEM\n"
                        "\t\\equ $bs    $SYS_IOBS_V\n"
                        "\t\\equ $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\\equ $cmd   $SYS_IOCMD_SPRF\n"
                        "\t\\equ $fmt   $SYS_IOFMT_BIN\n"
                        "\t\\equ $sep   <$SYS_IOPSEP_NOP .or. $SYS_IOWSEP_NOP>\n"
                        "\t\\equ $dev   $SYS_IODEV_MEM\n"
                        "\t\\equ $l     0.%1\n"
                        "\t\\equ $bs    $SYS_IOBS_V\n"
                        "\t\\equ $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(ap3);
            va_end(ap);
            asm("\t$io_cnt_clear\n"
                "\t$io_end\n"
                "\t!! end mvfprintf()\n"
                "\tlmtr %0 $MEM_SYS_RVAL\n"
                : "=r" (sys_retval) );
            
            return (int) (sys_retval.hi);
        }
}
#endif // mvfprintf()
#endif // Has Main

/*--------------------------------------------------------------------------------------------------
/!
\par NAME   
  slread(), mfread(), mfwrite() -  binary stream input/output for slices                        \n
                                                                                                \n
  slread() - read single data to slice of nodes                                                 \n
  mfread() - read multiple data to slice of nodes                                               \n
  mfwrite() - write multiple data to slice of nodes                                             \n

\par SYNOPSIS
  #include <stdio.h>                                                                            \n
                                                                                                \n
  size_t slead(int x1, int y1, int z1, [int x2, int y2, int z2,]
               void *ptr, size_t size, size_t nmemb, FILE *stream)                              \n
  size_t fread(int x1, int y1, int z1, [int x2, int y2, int z2,]
               void *ptr, size_t size, size_t nmemb, FILE *stream)                              \n
  size_t fwrite(int x1, int y1, int z1,[int x2, int y2, int z2,]
                void *ptr, size_t size, size_t nmemb, FILE *stream)                             \n

\par DESCRIPTION 
  See: fread(), fwrite()

\par RETURN VALUE
  See: fread(), fwrite()

\par BUG
  fmread, slread bug: if reading exeeds EOF, no data are read to memory and the memory remains
  unchanged

\par NOTE
  nodes read/write according to node_abs_id, starting with lowest number.
  (the id is calculated to be: node_abs_id = x*LY*LZ + y*LY + z)
*/
//--------------------------------------------------------------------------------------------------

#define __MF_ANZARGS 7
#define __TMF_ANZARGS 7

#define __MFSTART(ANZARGS) \
        int iocnt, retval, nbytes;\
        vector int argcnt, sys_rval;\
        size_t size, nmemb;\
        void *ptr;\
        FILE *stream;\
        va_list ap;\
        int x2 = x1, y2 = y1, z2 = z1;\
\
        va_start( ap, z1 );\
        argcnt = __builtin_argcount();\
        iocnt = argcnt.lo;\
\
        if (iocnt==ANZARGS+3) {\
                x2 = va_arg(ap, int);\
                y2 = va_arg(ap, int);\
                z2 = va_arg(ap, int);\
        }\
        else if (iocnt!=ANZARGS) return 0

#define __MFCHECK(STREAM) \
        assert( (nbytes%16)==0 );\
        stream = STREAM;\
        if( ! stream->fd ) {\
                errno = EBADF;\
                return 0;\
        }  

#define __MIOPACKET(IOCMD,IOBS,IORDFLG) \
      asm("\t$io_start\n"\
            "\t\\equl $cmd   "#IOCMD"\n"\
            "\t\\equl $fmt   $SYS_IOFMT_BIN\n"\
            "\t\\equl $sep   $SYS_IOPSEP_NOP\n"\
            "\t\\equl $rdflg "#IORDFLG"\n"\
            "\t\\equl $dev   $SYS_IODEV_MEM\n"\
            "\t\\equl $l     %1>>4\n"\
            "\t\\equl $bs    "#IOBS"\n"\
            "\t$io_fd( 0.%2 )\n"\
            "\t$io_slice(0.%4,0.%5,0.%6,0.%7,0.%8,0.%9)\n"\
            "\t$io_slice_set\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),\
               "r" (x1), "r" (y1), "r" (z1), "r" (x2), "r" (y2), "r" (z2) )

#define __MFEND \
        retval = nmemb;\
        where (sys_rval.lo) {\
                stream->err = 1;\
                retval = 0;\
        }\
\
        return retval

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

#define _MFIO(IOCMD,STREAM) \
        __MFSTART(__MF_ANZARGS);\
        ptr = va_arg(ap, void*);\
        size = va_arg(ap, size_t);\
        nmemb = va_arg(ap, size_t);\
        nbytes = size * nmemb;\
        __MFCHECK(STREAM);\
        __MIOPACKET(IOCMD,$SYS_IOBS_V,$SYS_IORDFLG_NOP);\
        __MFEND

#define _TMFIO(IOCMD,STREAM) \
        __MFSTART(__TMF_ANZARGS);\
        ptr = va_arg(ap, void*);\
        size = va_arg(ap, size_t);\
        nmemb = 1;\
        nbytes = size * nmemb;\
        __MFCHECK(STREAM);\
        if( (tcode==NLCC_FLOAT) || (tcode==NLCC_DOUBLE) ) {\
                __MIOPACKET(IOCMD,$SYS_IOBS_L,$SYS_IORDFLG_HZERO);\
        }\
        else if( (tcode==NLCC_INT) || (tcode==NLCC_UNSIGNED) ) {\
                __MIOPACKET(IOCMD,$SYS_IOBS_L,$SYS_IORDFLG_HMIRROR);\
        }\
        else if( (tcode==NLCC_COMPLEX) || (tcode==NLCC_VECTOR) || (tcode==NLCC_VFLOAT) || (tcode==NLCC_VINT) || (tcode==NLCC_VUINT) ) {\
                __MIOPACKET(IOCMD,$SYS_IOBS_V,$SYS_IORDFLG_NOP);\
        }\
        __MFEND

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

#ifdef __HAS_MAIN
#define BODY(args) args
#else
#define BODY(args) ;
#endif

#ifndef __HAS_MAIN
extern size_t slread(int x1, int y1, int z1, ...);
#else
#if !defined(__cflow_processed) || defined(_uses_slread_slice_stdio_os1_h)
size_t slread(int x1, int y1, int z1, ...) BODY({ _MFIO($SYS_IOCMD_BRD,(va_arg(ap, FILE*)));})  
#endif // slread()
#endif // Has Main

#ifndef __HAS_MAIN
extern size_t mfread(int x1, int y1, int z1, ...);
#else
#if !defined(__cflow_processed) || defined(_uses_mfread_slice_stdio_os1_h)
size_t mfread(int x1, int y1, int z1, ...) BODY({ _MFIO($SYS_IOCMD_MRD,(va_arg(ap, FILE*)));})  
#endif // mfread()
#endif // Has Main

#ifndef __HAS_MAIN
extern size_t mfwrite(int x1, int y1, int z1, ...);
#else
#if !defined(__cflow_processed) || defined(_uses_mfwrite_slice_stdio_os1_h)
size_t mfwrite(int x1, int y1, int z1, ...) BODY({ _MFIO($SYS_IOCMD_SWR,(va_arg(ap, FILE*)));}) 
#endif // mfwrite()
#endif // Has Main

#undef BODY


//-----------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define mscanf(ARGS...) mfscanf(stdin, ##ARGS)

#ifndef __HAS_MAIN
extern int mfscanf(FILE *stream, int x1, int y1, int z1, ...);
#else
#if !defined(__cflow_processed) || defined(_uses_mfscanf_slice_stdio_os1_h)
int mfscanf(FILE *stream, int x1, int y1, int z1, ...)
{
#pragma localmem

  int         iocnt;
  vector int  argcnt, arginfo, sys_rval;
  va_list     ap; 
  int         x2 = x1, y2 = y1, z2 = z1;
  char        *format;

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

  va_start(ap, z1);

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

  if (iocnt < 0) {                      // insufficient number of arguments
    errno = EINVAL;
    return 0;
  }

  // check if more node coordinates follow
  // by testing the argument type 
  //   if 'int' : read 3 more coords
  //   else     : assume it's the 'format' arg.
  { va_list     ap2; 
    vector int  arginfo; 
    void        *ptr = _va_ptr(ap2);

    va_copy(ap2, ap);
    arginfo = _va_info(ap2);
    if (arginfo.hi == NLCC_INT) {
      x2 = va_arg(ap, int);
      y2 = va_arg(ap, int);
      z2 = va_arg(ap, int);
      iocnt -= 3;
    }
  }

  format = va_arg(ap, char *);

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

  // set file descriptor, slice and output format string
  asm("\t$io_start\n"
      "\t$io_fd(0.%0)\n"
      "\t$io_slice(0.%3, 0.%4, 0.%5, 0.%6, 0.%7, 0.%8)\n"\
      "\t$io_cnt_set(%2)\n"
      "\t\\equ $cmd   $SYS_IOCMD_MSCF\n"
      "\t\\equ $fmt   $SYS_IOFMT_VARSTR\n"
      "\t\\equ $dev   $SYS_IODEV_MEM\n"
      "\t\\equ $bs    $SYS_IOBS_V\n"
      "\t\\equ $rdflg $SYS_IORDFLG_NOP\n"
      "\t$io_packet($cmd, $fmt, $rdflg, $dev, 0, $bs, 0.%1 )"
      : : "r" (stream->fd), "r" (format), "r" (iocnt),
          "r" (x1), "r" (y1), "r" (z1), 
          "r" (x2), "r" (y2), "r" (z2));

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

  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\\equ $cmd   $SYS_IOCMD_MSCF\n"
        "\t\\equ $fmt   $SYS_IOFMT_BIN\n"
        "\t\\equ $dev   $SYS_IODEV_MEM\n"
        "\t\\equ $l     1\n"
        "\t\\equ $bs    $SYS_IOBS_V\n"
        "\t\\equ $rdflg $SYS_IORDFLG_NOP\n"
        "\t$io_packet($cmd, $fmt, $rdflg, $dev, $l, $bs, 0.%0)\n"
        : :  "r" (ptr));
  }
  va_end(ap);

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

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

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

#endif    /* _NLIBC_OS1_SLICE_STDIO_H */

---