modules/io.js

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