Return to writes.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / icon / functions

Annotation of 43BSD/contrib/icon/functions/writes.c, revision 1.1

1.1     ! root        1: #include "../h/rt.h"
        !             2: 
        !             3: /*
        !             4:  * writes(a,b,...) - write arguments without newline terminator.
        !             5:  */
        !             6: 
        !             7: Xwrites(nargs)
        !             8: int nargs;
        !             9:    {
        !            10:    register int n;
        !            11:    char sbuf[MAXSTRING];
        !            12:    struct descrip arg;
        !            13:    FILE *f;
        !            14:    extern char *alcstr();
        !            15: 
        !            16:    f = stdout;
        !            17:    arg = nullstr;
        !            18: 
        !            19:    /*
        !            20:     * Loop through the arguments, dereferencing each in turn.
        !            21:     */
        !            22:    for (n = 1; n <= nargs; n++) {
        !            23:       arg = ARG(n);
        !            24:       DeRef(arg)
        !            25: 
        !            26:       if (!QUAL(arg) && TYPE(arg) == T_FILE) {/* Current argument is a file */
        !            27:          /*
        !            28:           * Switch the current file to the file named by the current argument
        !            29:           *  providing it is a file.  arg is made to be a empty string to
        !            30:           *  avoid a special case.
        !            31:           */
        !            32:          if ((BLKLOC(arg)->file.status & FS_WRITE) == 0)
        !            33:             runerr(213, &arg);
        !            34:          f = BLKLOC(arg)->file.fd;
        !            35:          arg = nullstr;
        !            36:          }
        !            37:       else {   /* Current argument is a string */
        !            38:          /*
        !            39:           * On first argument, check to be sure that &output is open
        !            40:           *  for output.
        !            41:           */
        !            42:          if (n == 1 && (k_output.status & FS_WRITE) == 0)
        !            43:             runerr(213, NULL);
        !            44:          /*
        !            45:           * Convert the argument to a string, defaulting to a empty string.
        !            46:           */
        !            47:          defany(&arg, &nullstr);
        !            48:          if (cvstr(&arg, sbuf) == NULL)
        !            49:             runerr(109, &arg);
        !            50:          /*
        !            51:           * Output the string and flush the file.
        !            52:           */
        !            53:          putstr(f, STRLOC(arg), STRLEN(arg));
        !            54:          fflush(f);
        !            55:          }
        !            56:       }
        !            57:    /*
        !            58:     * If the beginning of the last string output lies in sbuf,
        !            59:     *  allocate it as a real string.  Note that some of the string
        !            60:     *  conversions don't always leave the converted string at the
        !            61:     *  start of the conversion buffer, hence the range check.
        !            62:     */
        !            63:    if (STRLOC(arg) >= sbuf && STRLOC(arg) < sbuf + MAXSTRING) {
        !            64:       sneed(STRLEN(arg));
        !            65:       STRLOC(arg) = alcstr(STRLOC(arg), STRLEN(arg));
        !            66:       }
        !            67:    /*
        !            68:     * Return the string corresponding to the last argument.
        !            69:     */
        !            70:    ARG(0) = arg;
        !            71:    }
        !            72: 
        !            73: Procblock(writes,-1)

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.