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

   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

Defined variables

Defined macros