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 = parseInt("00002", 8);  /* write permission, others */
  13 const PERM_IWGRP = parseInt("00020", 8);  /* 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 = parseInt("0644", 8), $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 = parseInt("0644", 8), $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 var thread_manager = Cc["@mozilla.org/thread-manager;1"].getService(Ci.nsIThreadManager);
  97
  98 function input_stream_async_wait(stream, callback, requested_count) {
  99     stream = stream.QueryInterface(Ci.nsIAsyncInputStream);
 100     var flags = (requested_count === false) ? Ci.nsIAsyncInputStream.WAIT_CLOSURE_ONLY : 0;
 101     if (requested_count == null || requested_count == false)
 102         requested_count = 0;
 103     stream.asyncWait({onInputStreamReady: callback}, flags, requested_count, thread_manager.mainThread);
 104 }
 105
 106 function output_stream_async_wait(stream, callback, requested_count) {
 107     stream = stream.QueryInterface(Ci.nsIAsyncOutputStream);
 108     var flags = (requested_count === false) ? Ci.nsIAsyncOutputStream.WAIT_CLOSURE_ONLY : 0;
 109     if (requested_count == null || requested_count == false)
 110         requested_count = 0;
 111     stream.asyncWait({onOutputStreamReady: callback}, flags, requested_count, thread_manager.mainThread);
 112 }
 113
 114 function binary_output_stream(stream) {
 115     var s = Cc["@mozilla.org/binaryoutputstream;1"].createInstance(Ci.nsIBinaryOutputStream);
 116     s.setOutputStream(stream);
 117     return s;
 118 }
 119
 120 function binary_input_stream(stream) {
 121     var s = Cc["@mozilla.org/binaryinputstream;1"].createInstance(Ci.nsIBinaryInputStream);
 122     s.setInputStream(stream);
 123     return s;
 124 }
 125
 126 //  callback is called with null if the write succeeded, and an error otherwise
 127 function async_binary_write(stream, data, callback) {
 128     var data1 = data;
 129     function attempt_write() {
 130         try {
 131             while (true) {
 132                 if (data.length == 0) {
 133                     stream.flush();
 134                     if (callback != null)
 135                         callback(null);
 136                     return;
 137                 }
 138                 var len = stream.write(data, data.length);
 139                 if (len == 0)
 140                     break;
 141                 data = data.substring(len);
 142             }
 143         }
 144         catch (e if (e instanceof Components.Exception) && e.result == Cr.NS_BASE_STREAM_WOULD_BLOCK) {}
 145         catch (e) {
 146             if (callback != null)
 147                 callback(e);
 148             return;
 149         }
 150         output_stream_async_wait(stream, attempt_write, data.length);
 151     }
 152     attempt_write();
 153 }
 154
 155 /**
 156  * The `str' parameter should be a normal JavaScript string whose char codes specify Unicode code points.
 157  * The return value is a byte string (all char codes are from 0 to 255) equal to the `str' encoded in the specified charset.
 158  * If charset is not specified, it defaults to UTF-8.
 159  */
 160 function encode_string(str, charset) {
 161     var converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"].createInstance(Ci.nsIScriptableUnicodeConverter);
 162     converter.charset = charset || "UTF-8";
 163     var output = converter.ConvertFromUnicode(str);
 164     output += converter.Finish();
 165     return output;
 166 }
 167
 168
 169
 170 /**
 171  * The `bstr' parameter should be a byte string (all char codes are from 0 to 255).
 172  * The return value is a normal JavaScript unicode sring equal to `bstr' decoded using the specified charset.
 173  * If charset is not specified, it defaults to UTF-8.
 174  */
 175 function decode_string(bstr, charset) {
 176     var converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"].createInstance(Ci.nsIScriptableUnicodeConverter);
 177     converter.charset = charset  || "UTF-8";
 178     return converter.ConvertToUnicode(bstr);
 179 }
 180
 181 /* Calls callback when the write has completed.  If callback is null,
 182    the stream is closed when the write completes. */
 183 function async_binary_string_writer(bstr, callback) {
 184     return function (stream) {
 185         function modified_callback (e) {
 186             if (callback == null) {
 187                 stream.close();
 188             } else {
 189                 callback(stream, e);
 190             }
 191         }
 192         async_binary_write(stream, bstr, modified_callback);
 193     };
 194 }
 195
 196 function async_binary_reader(callback) {
 197     return function (stream) {
 198         var bstream = binary_input_stream(stream);
 199         function handler() {
 200             try {
 201                 let avail = stream.available();
 202                 if (avail > 0) {
 203                     callback(bstream.readBytes(avail));
 204                 }
 205                 input_stream_async_wait(stream, handler);
 206             } catch (e) {
 207                 callback(null);
 208             }
 209         }
 210         input_stream_async_wait(stream, handler);
 211     };
 212 }
 213
 214 function string_input_stream(data) {
 215     var string_stream = Cc["@mozilla.org/io/string-input-stream;1"].createInstance(Ci.nsIStringInputStream);
 216     string_stream.data = data;
 217     return string_stream;
 218 }
 219
 220 function mime_input_stream(stream, headers) {
 221     var mime_stream = Cc["@mozilla.org/network/mime-input-stream;1"].createInstance(Ci.nsIMIMEInputStream);
 222     if (headers) {
 223         for each (let [name,value] in headers) {
 224             mime_stream.addHeader(name,value);
 225         }
 226     }
 227     mime_stream.addContentLength = true;
 228     mime_stream.setData(stream);
 229     return mime_stream;
 230 }
 231
 232 provide("io");