Return to b3fil.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / B / src / bint

Annotation of 43BSD/contrib/B/src/bint/b3fil.c, revision 1.1

1.1     ! root        1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
        !             2: 
        !             3: /*
        !             4:   $Header: b3fil.c,v 1.4 85/08/27 10:56:00 timo Exp $
        !             5: */
        !             6: 
        !             7: /* Facilities supplied by the file system */
        !             8: 
        !             9: #include "b.h"
        !            10: #include "b0con.h"
        !            11: #include "b0fea.h"
        !            12: #include "b0fil.h"
        !            13: #include "b1obj.h"
        !            14: #include "b3scr.h"
        !            15: #include "b3err.h"
        !            16: #include "b3fil.h"
        !            17: 
        !            18: #ifndef INTEGRATION
        !            19: 
        !            20: /*This file defines the facilities needed for dealing with files,
        !            21:   apart from C's standard I/O facilities which are used throughout the system.
        !            22: 
        !            23:   Units are held on files in a 'workspace', which on Unix is modelled
        !            24:   using directories. The function 'f_uname' converts a unit name into a
        !            25:   unique filename. On Unix this is done by prepending a character to the unit
        !            26:   name to indicate the kind of unit (for how'to ', and for tests and yields
        !            27:   < for zeroadic, " for monadic and > for dyadic; these have been chosen as
        !            28:   characters that are not usually used in filenames), and truncating the
        !            29:   name if necessary. If the name does have to be truncated, then it is
        !            30:   hashed to produce a character that is appended to the filename, in an attempt
        !            31:   to produce a unique filename. Even so, it is still possible for different
        !            32:   unit names to produce the same filename, and in the unlikely event of this
        !            33:   happening you get an error message that the unit already exists when you
        !            34:   try to create the clashing unit name.
        !            35: 
        !            36:   Filenames are at most SAFEFNLEN characters long, which on standard Unix
        !            37:   systems gives you one spare character for making backups or whatever.
        !            38: 
        !            39:   It would be better if the B system effectively maintained its own directories
        !            40:   that mapped units onto files in the real file system, as is done for targets.
        !            41:   With operating systems with a more limited file system (eg even shorter
        !            42:   filenames) this is the only possibility.
        !            43: 
        !            44:   The B system can operate in two ways: with the interpreter in command,
        !            45:   and then the editor is called from the interpreter to edit units;
        !            46:   and with the editor in command, when the editor calls the interpreter to
        !            47:   execute commands. The variable 'filtered' is Yes when the editor is in
        !            48:   command, and No otherwise.
        !            49: */
        !            50: 
        !            51: #define COML 60
        !            52: Hidden char com_line[COML];
        !            53: #define At_eos(s) ((s)+= strlen(s))
        !            54: 
        !            55: Visible Procedure f_edit(fname, errline) value fname; intlet errline; {
        !            56:        /*The default editor is called with a first parameter of the line number
        !            57:          and a second parameter of the file name*/
        !            58:        string cl= com_line; char c;
        !            59: #ifdef unix
        !            60:        if (filtered) {
        !            61:                printf("\001: +%d %s\n", errline, strval(fname));
        !            62:                fflush(stdout);
        !            63:                do { c= fgetc(stdin); } while (c != '\n');
        !            64:                still_ok= Yes; /*ignore interrupts that occurred*/
        !            65:        } else {
        !            66:                strcpy(cl, editorfile);
        !            67:                if (*(cl+strlen(cl)-1) == '+') {
        !            68:                        if (errline != 0) sprintf(At_eos(cl), "%d", errline);
        !            69:                        else *(cl+strlen(cl)-1)= ' ';
        !            70:                }
        !            71:                app_fname(At_eos(cl), fname);
        !            72:                system(com_line);
        !            73:        }
        !            74: #else !unix
        !            75:        fprintf(stderr, "*** Editing units not yet implemented\n");
        !            76: #endif unix
        !            77: }
        !            78: 
        !            79: #else INTEGRATION
        !            80: 
        !            81: Visible Procedure
        !            82: f_edit(fname, errline, prompt)
        !            83:        value fname; intlet errline; literal prompt;
        !            84: {
        !            85:        string filename= Str(fname);
        !            86:        btop(&filename, errline, prompt, 0);
        !            87:        still_ok= Yes;
        !            88: }
        !            89: 
        !            90: #endif
        !            91: 
        !            92: Visible bool ws_writable() {
        !            93:        FILE *f= fopen(tempfile, "w");
        !            94:        if (f == NULL) return No;
        !            95:        fclose(f);
        !            96:        return Yes;
        !            97: }
        !            98: 
        !            99: Hidden bool f_copy(fname, sname) value fname, sname; {
        !           100:        string fn= strval(fname), sn;
        !           101:        FILE *fp= fopen(fn, "r"), *sp; int c; bool ok;
        !           102:        if (fp == NULL) return No;
        !           103:        sn= strval(sname);
        !           104:        sp= fopen(sn, "w");
        !           105:        if (sp == NULL) {
        !           106:                fclose(fp);
        !           107:                return No;
        !           108:        }
        !           109:        while ((c= getc(fp)) != EOF)
        !           110:                putc(c, sp);
        !           111:        fclose(fp);
        !           112:        ok= fflush(sp) != EOF;
        !           113:        if (fclose(sp) == EOF)
        !           114:                ok= No;
        !           115:        return ok;
        !           116: }
        !           117: 
        !           118: Visible value f_save(fname) value fname; {
        !           119:        /* saves the file in a temporary file, whose name is returned */
        !           120:        value sname= mk_text(tempfile);
        !           121:        VOID f_copy(fname, sname);
        !           122:        return sname;
        !           123: }
        !           124: 
        !           125: Visible Procedure f_rename(fname, nfname) value fname, nfname; {
        !           126:        char *f1, f2[100];
        !           127:        strcpy(f2, strval(nfname));
        !           128:        unlink(f2);
        !           129:        f1= strval(fname);
        !           130: #ifndef RENAME
        !           131:        link(f1, f2);
        !           132:        unlink(f1);
        !           133: #else
        !           134:        rename(f1, f2);
        !           135: #endif
        !           136:        /* what if it fails??? */
        !           137: }
        !           138: 
        !           139: Visible Procedure f_delete(fname) value fname; {
        !           140:        unlink(strval(fname));
        !           141: }
        !           142: 
        !           143: Visible bool
        !           144: f_exists(file)
        !           145:        string file;
        !           146: {
        !           147:        FILE *f= fopen(file, "r");
        !           148:        if (f==NULL) return No;
        !           149:        fclose(f);
        !           150:        return Yes;
        !           151: }
        !           152: 
        !           153: #ifndef INTEGRATION
        !           154: 
        !           155: Hidden Procedure app_fname(ceos, fname) string ceos; value fname; {
        !           156:        string fp= strval(fname); intlet k, len= strlen(fp);
        !           157:        *ceos++= ' ';
        !           158:        k_Over_len {
        !           159:                *ceos++= '\\';
        !           160:                *ceos++= *fp++; /*should really use charval(thof(...))*/
        !           161:        }
        !           162:        *ceos= '\0';
        !           163: }
        !           164: 
        !           165: #endif
        !           166: 
        !           167: Visible unsigned f_size(ifile) FILE *ifile; {
        !           168:        long size, ftell();
        !           169:        fseek(ifile, 0l, 2);
        !           170:        size= ftell(ifile);
        !           171:        fseek(ifile, 0l, 0); /* rewind */
        !           172:        return size;
        !           173: }
        !           174: 
        !           175: Visible Procedure f_close(ofile) FILE *ofile; {
        !           176:        bool ok= fflush(ofile) != EOF;
        !           177:        if (fclose(ofile) == EOF || !ok)
        !           178:                error(MESS(3203, "write error (disk full?)"));
        !           179: }
        !           180: 
        !           181: Visible bool f_interactive(ifile) FILE *ifile; {
        !           182: #ifdef ISATTY
        !           183:        return isatty(fileno(ifile));
        !           184: #else
        !           185:        return fileno(ifile) < 3;
        !           186: #endif
        !           187: }
        !           188: 
        !           189: #ifdef IBMPC
        !           190: 
        !           191: #define FNMLEN 8
        !           192: #define TYPLEN 3
        !           193: #define SPCLEN 1
        !           194: 
        !           195: #define FHW "how"
        !           196: #define FZR "zer"
        !           197: #define FMN "mon"
        !           198: #define FDY "dya"
        !           199: #define FTR "tar"
        !           200: 
        !           201: Hidden string
        !           202: filetype(type)
        !           203:        literal type;
        !           204: {
        !           205:        switch (type) {
        !           206:                case Zer:       return FZR;
        !           207:                case Mon:       return FMN;
        !           208:                case Dya:       return FDY;
        !           209:                case How:       return FHW;
        !           210:                case Tar:       return FTR;
        !           211:                default:        syserr(MESS(3200, "filetype()"));
        !           212:                                /* NOTREACHED */
        !           213:        }
        !           214: }
        !           215: 
        !           216: Hidden Procedure
        !           217: cr_fname(name, type, fname, len, pname)
        !           218:        value name; string fname, *pname; literal type; int len;
        !           219: {
        !           220:        *pname= fname;
        !           221:        strncpy(*pname, strval(name), len);
        !           222:        sprintf(fname + len, ".%s", filetype(type));
        !           223: }
        !           224: 
        !           225: #endif IBMPC
        !           226: 
        !           227: #ifdef unix
        !           228: 
        !           229: #define FNMLEN 12
        !           230: #define TYPLEN 1
        !           231: #define SPCLEN 0
        !           232: 
        !           233: #define FHW '\''
        !           234: #define FZR '<'
        !           235: #define FMN '"'
        !           236: #define FDY '>'
        !           237: #define FTR '='
        !           238: 
        !           239: Hidden literal
        !           240: filetype(type)
        !           241:        literal type;
        !           242: {
        !           243:        switch (type) {
        !           244:                case Zer:       return FZR;
        !           245:                case Mon:       return FMN;
        !           246:                case Dya:       return FDY;
        !           247:                case How:       return FHW;
        !           248:                case Tar:       return FTR;
        !           249:                default:        syserr(MESS(3201, "filetype()"));
        !           250:                                /* NOTREACHED */
        !           251:        }
        !           252: }
        !           253: 
        !           254: Hidden Procedure
        !           255: cr_fname(name, type, fname, len, pname)
        !           256:        value name; string fname, *pname; literal type; int len;
        !           257: {
        !           258:        *fname= filetype(type);
        !           259:        fname[1]= '\0';
        !           260:        *pname= fname + 1;
        !           261:        strncat(fname, strval(name), len);
        !           262: }
        !           263: 
        !           264: #endif unix
        !           265: 
        !           266: Hidden bool
        !           267: exists(name)
        !           268:        string name;
        !           269: {
        !           270:        value v= mk_text(name);
        !           271:        bool exist= in(v, file_names);
        !           272:        release(v);
        !           273:        return exist;
        !           274: }
        !           275: 
        !           276: Visible value
        !           277: new_fname(name, type)
        !           278:        value name; literal type;
        !           279: {
        !           280:        char fname[FNMLEN + TYPLEN + SPCLEN + 1];
        !           281:        intlet len= length(name);
        !           282:        string pname;
        !           283:        if (len > FNMLEN) len= FNMLEN;
        !           284:        cr_fname(name, type, fname, len, &pname);
        !           285:        while (exists(fname)) new(pname, len-1);
        !           286:        return mk_text(fname);
        !           287: }
        !           288: 
        !           289: #include <ctype.h>
        !           290: 
        !           291: Hidden Procedure
        !           292: new(name, n)
        !           293:        string name; int n;
        !           294: {
        !           295:        if (n < 1) error(MESS(3202, "too many units"));
        !           296:        else if (!isdigit(name[n])) name[n]= '1';
        !           297:        else if (name[n] != '9') ++name[n];
        !           298:        else {
        !           299:                name[n]= '0';
        !           300:                new(name, --n);
        !           301:        }
        !           302: }

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