Return to write.c CVS log

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

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

1.1     ! root        1: #include "../h/rt.h"
        !             2: 
        !             3: /*
        !             4:  * write(a,b,...) - write arguments.
        !             5:  */
        !             6: 
        !             7: Xwrite(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:           * If this isn't the first argument, output a newline to the current
        !            29:           *  file and flush it.
        !            30:           */
        !            31:          if (n > 1) {
        !            32:             putc('\n', f);
        !            33:             fflush(f);
        !            34:             }
        !            35:          /*
        !            36:           * Switch the current file to the file named by the current argument
        !            37:           *  providing it is a file.  arg is made to be a empty string to
        !            38:           *  avoid a special case.
        !            39:           */
        !            40:          if ((BLKLOC(arg)->file.status & FS_WRITE) == 0)
        !            41:             runerr(213, &arg);
        !            42:          f = BLKLOC(arg)->file.fd;
        !            43:          arg = nullstr;
        !            44:          }
        !            45:       else {   /* Current argument is a string */
        !            46:          /*
        !            47:           * On first argument, check to be sure that &output is open
        !            48:           *  for output.
        !            49:           */
        !            50:          if (n == 1 && (k_output.status & FS_WRITE) == 0)
        !            51:             runerr(213, NULL);
        !            52:          /*
        !            53:           * Convert the argument to a string, defaulting to a empty string.
        !            54:           */
        !            55:          defany(&arg, &nullstr);
        !            56:          if (cvstr(&arg, sbuf) == NULL)
        !            57:             runerr(109, &arg);
        !            58:          /*
        !            59:           * Output the string.
        !            60:           */
        !            61:          putstr(f, STRLOC(arg), STRLEN(arg));
        !            62:          }
        !            63:       }
        !            64:    /*
        !            65:     * Append a newline to the file and flush it.
        !            66:     */
        !            67:    putc('\n', f);
        !            68:    fflush(f);
        !            69:    /*
        !            70:     * If the beginning of the last string output lies in sbuf,
        !            71:     *  allocate it as a real string.  Note that some of the string
        !            72:     *  conversions don't always leave the converted string at the
        !            73:     *  start of the conversion buffer, hence the range check.
        !            74:     */
        !            75:    if (STRLOC(arg) >= sbuf && STRLOC(arg) < sbuf + MAXSTRING) {
        !            76:       sneed(STRLEN(arg));
        !            77:       STRLOC(arg) = alcstr(STRLOC(arg), STRLEN(arg));
        !            78:       }
        !            79:    /*
        !            80:     * Return the string corresponding to the last argument.
        !            81:     */
        !            82:    ARG(0) = arg;
        !            83:    }
        !            84: 
        !            85: Procblock(write,-1)

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