jsos

deviceDriverFilesystem.js

(17197B)

 /* ----------------------------------
    DeviceDriverFilesystem.js
    
    Requires deviceDriver.js
    
    The Kernel Filesystem Device Driver.
  
    ---------------------------------- */
 
 DeviceDriverFilesystem.prototype = new DeviceDriver;  // "Inherit" from prototype
 
 function DeviceDriverFilesystem() {
   
   /* TSB of root directory. */
   this.rootDir = undefined;
 
   /* TSB of current working directory. */
   this.cd = undefined;
 
   this.driverEntry = function() {
 
     // set all tsb's that dont exist to zeros
     //this.init();
     var rootTSB = new tsb(1,1,1);
     
     // init if it hasn't been before
     if(_Disk.readByte(rootTSB,1) == undefined)
       this.initBlockDirectory(rootTSB);
     this.rootDir = new Directory(rootTSB);
     this.cd = this.rootDir;
 
     this.status = "loaded";
   };
   
   /*
    * Formats entire filesystem by setting it to intial use.
    */
   this.format = function() {
     for(t=1; t<=_Disk.TRACKS; t++)
       for(s=1; s<=_Disk.SECTORS; s++)
         for(b=1; b<=_Disk.BLOCKS; b++) {
           var ts = new tsb(t,s,b);
           if(_Disk.read(ts).length == 0)
             _Disk.write(ts,[0], true);
           else {
             var file = new File(ts);
             if(file.type() != file.TYPE_SWAP) 
               _Disk.write(ts,[0], true);
           }
         }
 
     return true;
   };
 
   /* 
    * Initializes a block with type text & as unavailable 
    * with next block (0,0,0) & GS=1D 
    */
   this.initBlockTextFile = function(ts) {
     var value = ["1","0","0","0","1d"]; 
     _Disk.write(ts,value, true);
   };
 
   /* 
    * Initializes a block with type directory & as 
    * unavailable with next block (0,0,0) & GS=1D 
    */
   this.initBlockDirectory = function(ts) {
     var value = ["3","0","0","0","1d"]; 
     _Disk.write(ts,value, true);
   };
 
   /* 
    * Initializes a block with type swap & as unavailable 
    * with next block (0,0,0) 
    */
   this.initBlockSwap = function(ts) {
     var value = ["5","0","0","0"]; 
     _Disk.write(ts,value, true);
   };
 
  /*
   * Finds an available block in disk. 
   */
   this.getAvailableBlock = function() {
     for(t=1; t<=_Disk.TRACKS; t++)
       for(s=1; s<=_Disk.SECTORS; s++)
         for(b=1; b<=_Disk.BLOCKS; b++) {
           var ts = new tsb(t,s,b);
           var f = new File(ts);
           if(f.available() || _Disk.readByte(ts,1) == undefined)
             return ts;
         }
     return undefined;
   };
 
   /*
    * Creates a text file with a name.
    */
   this.createTextFile = function(fn) {
     fn = fn.trim();
     fn = this.rename(fn);
     var tsb = this.getAvailableBlock();
     if(tsb == undefined) return false;
 
     this.initBlockTextFile(tsb);
     var textFile = new TextFile(tsb);
     textFile.setName(fn);
     return this.cd.addTextFile(textFile);
   };
 
   /*
    * Creates a directory file with a name.
    */
   this.createDirectory = function(fn) {
     fn = fn.trim();
     fn = this.rename(fn);
     var tsb = this.getAvailableBlock();
     if(tsb == undefined) return false;
 
     this.initBlockDirectory(tsb);
     var dir = new Directory(tsb);
     dir.setName(fn);
     return this.cd.addDirectory(dir);
   };
 
   /*
    * Writes text to a text file under a name.
    */
   this.writeTextFile = function(fn, text) {
     fn = fn.trim();
     var file = this.cd.getTextFile(fn);
     if(file == undefined) return false;
     return file.setText(text);
   };
 
   /*
    * Reads text to a text file under a name.
    */
   this.readTextFile = function(fn) {
     fn = fn.trim();
     var file = this.cd.getTextFile(fn);
     if(file == undefined)
       return undefined;
     return file.text();
   };
 
   /*
    * Deletes a file with a name.
    */
   this.deleteFile = function(fn) {
     fn = fn.trim();
     return this.cd.deleteFile(fn);
   };
 
   /*
    * List working directory contents.
    */
   this.ls = function() {
     return this.cd.directories().concat(this.cd.textFiles());
   };
 
   /*
    * Changes working directory.
    */
   this.changeDirectory = function(fn) {
     fn = fn.trim();
 
     if(fn=="..") {
       if(this.cd.parentDirectory() != undefined) {
         this.cd = this.cd.parentDirectory();
         return true;
       } else 
         return false;
     }
     if(fn==".") {
       return true;
     }
 
     var dir = this.cd.getDirectory(fn);
     if(dir != undefined) {
       this.cd = dir;
       return true;
     }
     return false;
   };
 
   /*
    * Rename file name if existing file name is in this 
    * working directory. Pads it with zero (exponentially).
    */
   this.rename = function(name,suffix) {
     if(suffix==undefined) suffix=0;
 
     var dirs = this.cd.directories();
     var txtFiles = this.cd.textFiles();
 
     for(var i = 0; i < dirs.length; i++) {
       var name1 = dirs[i].name();
       if(name1 == name)
         return this.rename(name+pad("",suffix+1), suffix+1);
     }
     for(var i = 0; i < txtFiles.length; i++) {
       if(txtFiles[i].name() == name)
         return this.rename(name+pad("",suffix+1), suffix+1);
     }
 
     return name;
   };
 };
 
 
 /*----------------------------------------------------------
 
    Anything saved in disk is a file. 
    One file can take multiple blocks in disk.
 
    Header format for each block:
    status , track , sector , block (1 byte each)
 
    header: 4 bytes
    payload: 60 bytes
 
    Status represents type and availability flag bits:
 
    ----------------------------------------
    |X|X|X|X|X| type | type | availability |
    ----------------------------------------
 
    file types: 0=text, 1=directory, 2=swap
    availability: 0=available 1=unavailable
 
 
    Header(4 bytes)
    -----------------------------------
    | Status | Track | Sector | Block |
    -----------------------------------
 
    Track, Sector, Block points to the next block in disk if 
    the payload is greater than 60 bytes. It's set to zero 
    if it's the last block in the file.
 
 ----------------------------------------------------------*/
 function File(TSB) {
 
   this.TYPE_TEXT = 0;
   this.TYPE_DIR  = 1;
   this.TYPE_SWAP = 2;
 
   /* Header size of file. */
   this.HEADER_SIZE = 4;
   
   this.tsb = TSB;
   this.all_tsb = [TSB];
 
   /*
    * Gets the data of this file from disk.
    */
   this.data = function() {
     var data = _Disk.read(this.tsb);
     var header = data.slice(0, this.HEADER_SIZE);
     while(this.next(header) != undefined) {
       var tsb = this.next(header);
       var extData = _Disk.read(tsb);
       header = extData.slice(0, this.HEADER_SIZE);
       extData = extData.slice(this.HEADER_SIZE, extData.length);
       data = data.concat(extData);
     }
     return data;
   };
 
   /*
    * Write data to this file.
    * @param clear erase existing data
    */
   this.write = function(data, clear) {
     if(clear) {
       // set all TSB's to available
       for(i=1; i<this.all_tsb.length; i++)
         _Disk.write(this.all_tsb[i], [0], true);
       this.all_tsb = this.all_tsb.slice(0,1);
 
       // clear data in all tsb's
       var header = this.data().slice(0, this.HEADER_SIZE);
       while(this.next(header) != undefined) {
         var tsb = this.next(header);
         var extData = _Disk.read(tsb);
         header = extData.slice(0, this.HEADER_SIZE);
         _Disk.write(tsb, [0], clear);
       }
 
     } else {
       data = this.data().concat(data);   
     }
 
     return this.writeData(data, clear);
   }
 
   /*
    * Called by this write function.
    */
   this.writeData = function(data,clear) {
     var ts = this.tsb;
     while(data.length > 0) {
         data = _Disk.write(ts, data, clear);
 
         // get extra block if data does not fit
         if(data.length > 0) {
           var ts1 = krnFilesystemDriver.getAvailableBlock();
           if(ts1 == undefined) return false;
           this.all_tsb.push(ts1);
           this.setNext(ts, ts1);
           ts = ts1;
           data = [this.data()[0],"0","0","0"].concat(data);
         }      
       }
     return true;
   }
 
   /*
    * Get the next block if the data in this block 
    * continues to another one.
    */
   this.next = function(data) {
     var track = data[1];
     var sector = data[2];
     var block = data[3];
 
     if(track==0 || sector==0 || block==0 ||
        track==undefined || sector==undefined || block==undefined)
       return undefined;
     return new tsb(track, sector, block);
   };
 
   /*
    * Sets the next, contuining block so data can grow over 
    * fixed block size.
    */
   this.setNext = function(tsb, tsbNext) {
     return _Disk.writeByte(tsb,2, tsbNext.track) &&
            _Disk.writeByte(tsb,3, tsbNext.sector) &&
            _Disk.writeByte(tsb,4, tsbNext.block);
   };
 
   /*
    * Get the availability status (to read and/or 
    * write) of the block.
    * If true, block is available, else it's occupied.
    */
   this.available = function() {
     var byte = parseInt(this.data()[0]);
     var bit = pad(byte.toString(2),8).substring(7,8);
     return bit == 0 ? true : false;
   };
 
   /*
    * Get the type of the block.
    * If true, it's a file, else it's a directory.
    */
   this.type = function() {
     var data = this.data();
     var byte = parseInt(data.slice(0,1)[0]);
     var typeBinary = pad(byte.toString(2),8).substring(5,7);
     var type = parseInt(typeBinary, 2);
     return type;
   };
 
   /*
    * Returns the data excluding the header.
    */
   this.payload = function() {
     var data = this.data();
     return data.slice(this.HEADER_SIZE, data.length);
   };
 };
 
 
 
 /*----------------------------------------------------------
 
    A directory is a type of file with a file header and payload.
 
 
    Format of the payload:
    -----------------------------
    | File Name | GS | Data.... |
    -----------------------------
 
    The first thing in the payload is the file name that can 
    be any length. The file name is separated by a 
    "Group Separator" (hex value: 0x1D). 
 
    The rest of the payload is a listing of all files' 
    track-sector-block location.
    ---------------------------------------------------------
    | track | sector | block | track | sector | block | etc |
    --------------------------------------------------------- 
 
    The first TSB is the parent directory.
 
 ----------------------------------------------------------*/
 Directory.prototype = new File();
 function Directory(TSB) {
   File.call(this, TSB);
 
   /*
    * Returns a directory of this directory's parent directory.
    */
   this.parentDirectory = function() {
     if(this.tsb.toString() != "111") { // not root directory
       var ts = this.data().slice(this.gs()+1, this.gs()+4);
       return new Directory(new tsb(ts[0],ts[1],ts[2]));
     } else
       return undefined;
   };
 
   /*
    * Returns the location of the group separator.
    * @param Including only the payload?
    */
   this.gs = function(payload) {
     var data = payload ? this.payload() : this.data();
 
     for(i=0; i<data.length; i++)
       if(data[i] == "1d")
         return i;
   };
 
   /*
    * Returns the name of this file.
    */
   this.name = function() {
     var hex_name = this.data().slice(this.HEADER_SIZE, this.gs(false));
     var name = "";
 
     for(i=0; i<hex_name.length; i++) 
       name += hex2ASCII(hex_name[i]);
 
     return name;
   };
 
   /*
    * Returns all files in this directory, 
    * including text files and directories.
    */
   this.files = function() {
     var data = this.payload();
     data = data.slice(this.gs(true)+1, data.length);
 
     var files = [];
     for(i=0; i<data.length; i+=3) {
       var ts = new tsb(data[i], data[i+1], data[i+2]);
       if(ts != undefined)
         files.push(new File(ts));
     }
       
     return files;
   };
 
   /*
    * Returns all directories in this directory.
    */
   this.directories = function() {
     var dirs = [];
     var files = this.files();
     for(var i = 0; i < files.length; i++) {
       if(files[i].type() == this.TYPE_DIR) 
         dirs.push(new Directory(files[i].tsb));
     }
 
     if(this.tsb.toString() != "111") { // not root directory
       return dirs.slice(1, dirs.length);
     } else
       return dirs;
   };
 
   /*
    * Returns the directory that matches the specified name.
    */
   this.getDirectory = function(fn) {
     var directories = this.directories();
     for(var i=0; i<directories.length; i++)
       if(directories[i].name() == fn)
         return directories[i];
     return undefined;
   };
 
   /*
    * Returns all text files in this directory.
    */
   this.textFiles = function() {
     var textFiles = [];
     var files = this.files();
     for(i=0; i<files.length; i++)
       if(files[i].type() == this.TYPE_TEXT) 
         textFiles.push(new TextFile(files[i].tsb));
 
     return textFiles;
   };
 
   /*
    * Returns the text file that matches the specified name.
    */
   this.getTextFile = function(fn) {
     var textFiles = this.textFiles();
     for(var i=0; i < textFiles.length; i++)
       if(textFiles[i].name() == fn)
         return textFiles[i];
     return undefined;
   };
 
   /*
    * Adds a directory in this directory.
    */
   this.addDirectory = function(dir) {
     dir.write(dir.data().concat([this.tsb.track,this.tsb.sector,this.tsb.block]), true);
     var tsb = dir.tsb;
     var data = this.data().concat([tsb.track, tsb.sector, tsb.block]);
     return this.write(data, true);
   };
 
   /*
    * Adds a text file in this directory.
    */
   this.addTextFile = function(textFile) {
     var tsb = textFile.tsb;
     var data = this.data().concat([tsb.track, tsb.sector, tsb.block]);
     return this.write(data, true);
   };
 
   /*
    * Deletes a file in this directory matching name.
    */
   this.deleteFile = function(name) {
     var file = undefined;
     var directories = this.directories();
     var textFiles = this.textFiles();
 
     // find from directories
     for(var i = 0; i < directories.length; i++) {
       if(directories[i].name() == name) {
         file = directories[i];
         directories.splice[i,1];
       }
     }
 
     // find from text files
     for(var i = 0; i < textFiles.length; i++) {
       if(textFiles[i].name() == name) {
         file = textFiles[i];
         textFiles.splice[i,1];
       }
     }
 
     if(file == undefined)
       return false;
     else { 
       _Disk.write(file.tsb,[0], true);
       return this.deleteTSB(file.tsb);
     }
   };
 
   /*
    * Deletes a track-sector-block in this directory listing.
    */
   this.deleteTSB = function(tsb) {
     var data = this.data();
     var header = data.slice(0, this.gs(false)+1);
     var payload = data.slice(this.gs(false)+1, data.length);
 
     for(var i = 0; i < payload.length; i+=3) {
       if(tsb.track == payload[i] &&
          tsb.sector == payload[i+1] &&
          tsb.block == payload[i+2]) {
         payload[i]   = 0;
         payload[i+1] = 0;
         payload[i+2] = 0;
         return this.write(header.concat(payload), true);
       }
     }
     return false;
   };
 
   /*
    * Sets the name of this file.
    */
   this.setName = function(name) {
     var data = this.data();
     data = data.slice(0, this.HEADER_SIZE).concat(
            ascii2hex(name)).concat( 
            data.slice(this.gs(false), data.length));
 
     return this.write(data, true);
   };
 };
 
 
 
 /*----------------------------------------------------------
 
    A text file is a type of file with a file header and payload.
 
 
    Format of the payload:
    -----------------------------
    | File Name | GS | Data.... |
    -----------------------------
 
    The first thing in the payload is the file name that can 
    be any length. The file name is separated by a 
    "Group Separator" (hex value: 0x1D). 
 
    The rest of the payload is just ASCII bytes (in hex format).
 
 ----------------------------------------------------------*/
 TextFile.prototype = new File();
 function TextFile(TSB) {
   File.call(this, TSB);
 
   /*
    * Returns the location of the group separator.
    * @param Including only the payload?
    */
   this.gs = function(payload) {
     var data = payload ? this.payload() : this.data();
 
     for(i=0; i<data.length; i++)
       if(data[i] == "1d")
         return i;
   };
 
   /*
    * Gets the name of this file.
    */
   this.name = function() {
     var hex_name = this.data().slice(this.HEADER_SIZE, this.gs(false));
     var name = "";
 
     for(i=0; i<hex_name.length; i++) 
       name += hex2ASCII(hex_name[i]);
 
     return name;
   };
 
   /*
    * Gets the text of this file.
    */
   this.text = function() {
     var data = this.payload();
     data = data.slice(this.gs(true)+1, data.length);
 
     var text = "";
     for(var i=0; i < data.length; i++) {
       text += hex2ASCII(data[i]);
     }
     return text;
   };
 
   /*
    * Sets the name of this file.
    */
   this.setName = function(name) {
     var data = this.data();
     data = data.slice(0, this.HEADER_SIZE).concat(
            ascii2hex(name)).concat( 
            data.slice(this.gs(false), data.length));
 
     return this.write(data, true);
   };
 
   /*
    * Sets the text of this file.
    */
   this.setText = function(text) {
     var data = this.data().slice(0, this.gs(false)+1).concat(ascii2hex(text)); 
     return this.write(data,true);
   };
  };
 
 
 /*----------------------------------------------------------
 
    A swap is a type of file with a file header and payload.
 
 
    Format of the payload:
    ------------
    | Data.... |
    ------------
 
    Nothing special.
 
 ----------------------------------------------------------*/
 Swap.prototype = new File();
 function Swap(TSB) {
   File.call(this, TSB);
 };