modules/io.js

   1 const PERM_IWOTH = 00002;  /* write permission, others */
   2 const PERM_IWGRP = 00020;  /* write permission, group */
   3
   4 const MODE_RDONLY   = 0x01;
   5 const MODE_WRONLY   = 0x02;
   6 const MODE_RDWR     = 0x04;
   7 const MODE_CREATE   = 0x08;
   8 const MODE_APPEND   = 0x10;
   9 const MODE_TRUNCATE = 0x20;
  10 const MODE_SYNC     = 0x40;
  11 const MODE_EXCL     = 0x80;
  12 const MODE_OUTPUT = MODE_WRONLY | MODE_CREATE | MODE_TRUNCATE;
  13 const MODE_OUTPUT_APPEND = MODE_WRONLY | MODE_CREATE | MODE_APPEND;
  14 const MODE_INPUT = MODE_RDONLY;
  15
  16 define_keywords("$charset");
  17 function read_text_file(file)
  18 {
  19     keywords(arguments, $charset = "UTF-8");
  20
  21     var ifstream = null, icstream = null;
  22
  23     try {
  24         ifstream = Cc["@mozilla.org/network/file-input-stream;1"].createInstance(Ci.nsIFileInputStream);
  25         icstream = Cc["@mozilla.org/intl/converter-input-stream;1"].createInstance(Ci.nsIConverterInputStream);
  26
  27         ifstream.init(file, -1, 0, 0);
  28         const replacementChar = Ci.nsIConverterInputStream.DEFAULT_REPLACEMENT_CHARACTER;
  29         icstream.init(ifstream, arguments.$charset, 4096, replacementChar); // 4096 bytes buffering
  30
  31         var buffer = "";
  32         var str = {};
  33         while (icstream.readString(4096, str) != 0)
  34             buffer += str.value;
  35         return buffer;
  36     } finally  {
  37         if (icstream)
  38             icstream.close();
  39         if (ifstream)
  40             ifstream.close();
  41     }
  42 }
  43
  44 define_keywords("$mode", "$perms", "$charset");
  45 function write_text_file(file, buf)
  46 {
  47     keywords(arguments, $charset = "UTF-8", $perms = 0644, $mode = MODE_WRONLY | MODE_CREATE | MODE_TRUNCATE);
  48
  49     var ofstream, ocstream;
  50     try {
  51         ofstream = Cc["@mozilla.org/network/file-output-stream;1"].createInstance(Ci.nsIFileOutputStream);
  52         ocstream = Cc["@mozilla.org/intl/converter-output-stream;1"].createInstance(Ci.nsIConverterOutputStream);
  53
  54         ofstream.init(file, arguments.$mode, arguments.$perms, 0);
  55         ocstream.init(ofstream, arguments.$charset, 0, 0x0000);
  56         ocstream.writeString(buf);
  57     } finally {
  58         if (ocstream)
  59             ocstream.close();
  60         if (ofstream)
  61             ofstream.close();
  62     }
  63 }
  64
  65 define_keywords("$mode", "$perms");
  66 function write_binary_file(file, buf)
  67 {
  68     keywords(arguments, $perms = 0644, $mode = MODE_WRONLY | MODE_CREATE | MODE_TRUNCATE);
  69     var stream = null, bstream = null;
  70
  71     try {
  72         stream = Cc["@mozilla.org/network/file-output-stream;1"].createInstance(Ci.nsIFileOutputStream);
  73         stream.init(file, arguments.$mode, arguments.$perms, 0);
  74
  75         bstream = binary_output_stream(stream);
  76         bstream.writeBytes(buf, buf.length);
  77     } finally {
  78         if (bstream)
  79             bstream.close();
  80         if (stream)
  81             stream.close();
  82     }
  83 }
  84
  85 function get_file(path) {
  86     var f = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsILocalFile);
  87     f.initWithPath(path);
  88     return f;
  89 }
  90
  91 var thread_manager = Cc["@mozilla.org/thread-manager;1"].getService(Ci.nsIThreadManager);
  92
  93 function input_stream_async_wait(stream, callback, requested_count) {
  94     stream = stream.QueryInterface(Ci.nsIAsyncInputStream);
  95     var flags = (requested_count === false) ? Ci.nsIAsyncInputStream.WAIT_CLOSURE_ONLY : 0;
  96     if (requested_count == null || requested_count == false)
  97         requested_count = 0;
  98     stream.asyncWait({onInputStreamReady: callback}, flags, requested_count, thread_manager.mainThread);
  99 }
 100
 101 function output_stream_async_wait(stream, callback, requested_count) {
 102     stream = stream.QueryInterface(Ci.nsIAsyncOutputStream);
 103     var flags = (requested_count === false) ? Ci.nsIAsyncOutputStream.WAIT_CLOSURE_ONLY : 0;
 104     if (requested_count == null || requested_count == false)
 105         requested_count = 0;
 106     stream.asyncWait({onOutputStreamReady: callback}, flags, requested_count, thread_manager.mainThread);
 107 }
 108
 109 function binary_output_stream(stream) {
 110     var s = Cc["@mozilla.org/binaryoutputstream;1"].createInstance(Ci.nsIBinaryOutputStream);
 111     s.setOutputStream(stream);
 112     return s;
 113 }
 114
 115 function binary_input_stream(stream) {
 116     var s = Cc["@mozilla.org/binaryinputstream;1"].createInstance(Ci.nsIBinaryInputStream);
 117     s.setInputStream(stream);
 118     return s;
 119 }
 120
 121 //  callback is called with a single argument, either true if the write succeeded, or false otherwise
 122 function async_binary_write(stream, data, callback) {
 123     function attempt_write() {
 124         try {
 125             while (true) {
 126                 if (data.length == 0) {
 127                     stream.flush();
 128                     callback(true);
 129                     return;
 130                 }
 131                 var len = stream.write(data, data.length);
 132                 if (len == 0)
 133                     break;
 134                 data = data.substring(len);
 135             }
 136         }
 137         catch (e if (e instanceof Components.Exception) && e.result == Cr.NS_BASE_STREAM_WOULD_BLOCK) {}
 138         catch (e) {
 139             callback(false);
 140             return;
 141         }
 142         output_stream_async_wait(stream, attempt_write, data.length);
 143     }
 144     attempt_write();
 145 }
 146
 147 /**
 148  * The `str' parameter should be a normal JavaScript string whose char codes specify Unicode code points.
 149  * The return value is a byte string (all char codes are from 0 to 255) equal to the `str' encoded in the specified charset.
 150  * If charset is not specified, it defaults to UTF-8.
 151  */
 152 function encode_string(str, charset) {
 153     var converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"].createInstance(Ci.nsIScriptableUnicodeConverter);
 154     converter.charset = charset || "UTF-8";
 155     var output = converter.ConvertFromUnicode(str);
 156     output += converter.Finish();
 157     return output;
 158 }
 159
 160
 161
 162 /**
 163  * The `bstr' parameter should be a byte string (all char codes are from 0 to 255).
 164  * The return value is a normal JavaScript unicode sring equal to `bstr' decoded using the specified charset.
 165  * If charset is not specified, it defaults to UTF-8.
 166  */
 167 function decode_string(bstr, charset) {
 168     var converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"].createInstance(Ci.nsIScriptableUnicodeConverter);
 169     converter.charset = charset  || "UTF-8";
 170     return converter.ConvertToUnicode(bstr);
 171 }
 172
 173 function async_binary_string_writer(bstr) {
 174     return function (stream) {
 175         async_binary_write(stream, bstr);
 176     };
 177 }
 178
 179 function async_binary_reader(callback) {
 180     return function (stream) {
 181         var bstream = binary_input_stream(stream);
 182         function handler() {
 183             try {
 184                 let avail = stream.available();
 185                 if (avail > 0) {
 186                     callback(bstream.readBytes(avail));
 187                 }
 188                 input_stream_async_wait(stream, handler);
 189             } catch (e) {
 190                 callback(null);
 191             }
 192         }
 193         input_stream_async_wait(stream, handler);
 194     };
 195 }