Return to open.c CVS log

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

Annotation of 43BSD/contrib/icon/functions/open.c, revision 1.1.1.1

1.1       root        1: #include "../h/rt.h"
                      2: 
                      3: /*
                      4:  * open(s1,s2) - open file s1 with specification s2.
                      5:  */
                      6: Xopen(nargs, arg2, arg1, arg0)
                      7: int nargs;
                      8: struct descrip arg2, arg1, arg0;
                      9:    {
                     10:    register int slen, i;
                     11:    register char *s;
                     12:    int status;
                     13:    char sbuf1[MAXSTRING], sbuf2[MAXSTRING], mode[3];
                     14:    FILE *f;
                     15:    extern struct b_file *alcfile();
                     16:    extern char *alcstr();
                     17:    extern FILE *fopen(), *popen();
                     18: 
                     19:    /*
                     20:     * s1 must be a string and a C string copy of it is also needed.
                     21:     *  Make it a string if it isn't one; make a C string if s1 is
                     22:     *  a string.
                     23:     */
                     24:    switch (cvstr(&arg1, sbuf1)) {
                     25:       case 1:
                     26:          sneed(STRLEN(arg1));
                     27:          STRLOC(arg1) = alcstr(STRLOC(arg1), STRLEN(arg1));
                     28:          break;
                     29:       case 2:
                     30:          qtos(&arg1, sbuf1);
                     31:          break;
                     32:       default:
                     33:          runerr(103, &arg1);
                     34:       }
                     35:    /*
                     36:     * s2 defaults to "r".
                     37:     */
                     38:    defstr(&arg2, sbuf2, &letr);
                     39: 
                     40:    hneed(sizeof(struct b_file));
                     41:    status = 0;
                     42: 
                     43:    /*
                     44:     * Scan s2, setting appropriate bits in status.  Produce a runerr
                     45:     *  if an unknown character is encountered.
                     46:     */
                     47:    s = STRLOC(arg2);
                     48:    slen = STRLEN(arg2);
                     49:    for (i = 0; i < slen; i++) {
                     50:       switch (*s++) {
                     51:          case 'a': case 'A':
                     52:             status |= FS_WRITE|FS_APPEND;
                     53:             continue;
                     54:          case 'b': case 'B':
                     55:             status |= FS_READ|FS_WRITE;
                     56:             continue;
                     57:          case 'c': case 'C':
                     58:             status |= FS_CREATE|FS_WRITE;
                     59:             continue;
                     60:          case 'p': case 'P':
                     61:             status |= FS_PIPE;
                     62:             continue;
                     63:          case 'r': case 'R':
                     64:             status |= FS_READ;
                     65:             continue;
                     66:          case 'w': case 'W':
                     67:             status |= FS_WRITE;
                     68:             continue;
                     69:          default:
                     70:             runerr(209, &arg2);
                     71:          }
                     72:       }
                     73: 
                     74:    /*
                     75:     * Construct a mode field for fopen/popen.
                     76:     */
                     77:    mode[0] = '\0';
                     78:    mode[1] = '\0';
                     79:    mode[2] = '\0';
                     80:    if ((status & (FS_READ|FS_WRITE)) == 0)   /* default: read only */
                     81:       status |= FS_READ;
                     82:    if (status & FS_CREATE)
                     83:       mode[0] = 'w';
                     84:    else if (status & FS_APPEND)
                     85:       mode[0] = 'a';
                     86:    else if (status & FS_READ)
                     87:       mode[0] = 'r';
                     88:    else
                     89:       mode[0] = 'w';
                     90:    if ((status & (FS_READ|FS_WRITE)) == (FS_READ|FS_WRITE))
                     91:       mode[1] = '+';
                     92: 
                     93:    /*
                     94:     * Open the file with fopen or popen.
                     95:     */
                     96:    if (status & FS_PIPE) {
                     97:       if (status != (FS_READ|FS_PIPE) && status != (FS_WRITE|FS_PIPE))
                     98:          runerr(209, &arg2);
                     99:       f = popen(sbuf1, mode);
                    100:       }
                    101:    else
                    102:       f = fopen(sbuf1, mode);
                    103:    /*
                    104:     * Fail if the file can't be opened.
                    105:     */
                    106:    if (f == NULL)
                    107:       fail();
                    108:    /*
                    109:     * If the file isn't a terminal and a buffer is available, assign
                    110:     *  it to the file.
                    111:     */
                    112:    if (!isatty(fileno(f))) {
                    113:       for (i = 0; i < numbufs; i++)
                    114:          if (bufused[i] == NULL)
                    115:             break;
                    116:       if (i < numbufs) {              /* Use buffer if any free. */
                    117:          setbuf(f, bufs[i]);
                    118:          bufused[i] = f;
                    119:          }
                    120:       else
                    121:          setbuf(f, NULL);
                    122:       }
                    123:    else
                    124:       setbuf(f, NULL);
                    125:    /*
                    126:     * Return the resulting file value.
                    127:     */
                    128:    arg0.type = D_FILE;
                    129:    BLKLOC(arg0) = (union block *) alcfile(f, status, &arg1);
                    130:    }
                    131: 
                    132: Procblock(open,2)

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