# 2.11BSD#431 - /usr/src/new/PORT/B/src/bint/b3fil.c

##### Functions

    app_fname         X
    cr_fname          X
    exists            X
    f_close           X
    f_copy            X
    f_delete          X
    f_edit            X
    f_exists          X
    f_interactive     X
    f_rename          X
    f_save            X
    f_size            X
    filetype          X
    new               X
    new_fname         X
    ws_writable       X

##### Variables

    Hidden            X
    com_line          X

##### Macros

    At_eos            X
    COML              X
    FDY               X
    FHW               X
    FMN               X
    FNMLEN            X
    FTR               X
    FZR               X
    SPCLEN            X
    TYPLEN            X

       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: }

#### Defined functions

app_fname defined in line 155; used 1 times

- in line 71

cr_fname defined in line 254; used 1 times

- in line 284

exists defined in line 266; used 1 times

- in line 285

f_close defined in line 175; used 3 times

- in /usr/src/new/PORT/B/src/bint/b3sou.c line 350, 559, 815

f_copy defined in line 99; used 1 times

- in line 121

f_delete defined in line 139; used 6 times

- in /usr/src/new/PORT/B/src/bint/b3sou.c line 133, 459, 497-498(2), 519, 854

f_edit defined in line 81; used 4 times

- in /usr/src/new/PORT/B/src/bint/b3sou.c line 450-452(2), 683-685(2)

f_exists defined in line 143; used 3 times

- in /usr/src/new/PORT/B/src/bint/b3fil.h line 11
- in /usr/src/new/PORT/B/src/bint/b3sou.c line 762, 780

f_interactive defined in line 181; used 5 times

- in /usr/src/new/PORT/B/src/bint/b3err.c line 282
- in /usr/src/new/PORT/B/src/bint/b3fil.h line 14
- in /usr/src/new/PORT/B/src/bint/b3scr.c line 471, 477-478(2)

f_rename defined in line 125; used 5 times

- in /usr/src/new/PORT/B/src/bint/b3sou.c line 480, 491-496(2), 797, 817

f_save defined in line 118; used 2 times

- in /usr/src/new/PORT/B/src/bint/b3fil.h line 12
- in /usr/src/new/PORT/B/src/bint/b3sou.c line 443

f_size defined in line 167; used 2 times

- in /usr/src/new/PORT/B/src/bint/b3fil.h line 10
- in /usr/src/new/PORT/B/src/bint/b3sou.c line 735

filetype defined in line 239; used 2 times

- in line 222, 258

new defined in line 291; used 2 times

- in line 285, 300

new_fname defined in line 276; used 4 times

- in /usr/src/new/PORT/B/src/bint/b3fil.h line 16
- in /usr/src/new/PORT/B/src/bint/b3sou.c line 147, 479, 781

ws_writable defined in line 92; used 3 times

- in /usr/src/new/PORT/B/src/bint/b3fil.h line 9
- in /usr/src/new/PORT/B/src/bint/b3sou.c line 442, 681

#### Defined variables

Hidden defined in line 99; never used
com_line defined in line 52; used 2 times

- in line 58, 72

#### Defined macros

At_eos defined in line 53; used 2 times

- in line 68-71(2)

COML defined in line 51; used 1 times

- in line 52

FDY defined in line 236; used 2 times

- in line 208, 246

FHW defined in line 233; used 2 times

- in line 209, 247

FMN defined in line 235; used 2 times

- in line 207, 245

FNMLEN defined in line 229; used 3 times

- in line 280-283(3)

FTR defined in line 237; used 2 times

- in line 210, 248

FZR defined in line 234; used 2 times

- in line 206, 244

SPCLEN defined in line 231; used 1 times

- in line 280

TYPLEN defined in line 230; used 1 times

- in line 280

Last modified: 1985-08-27 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1439 |