modules/command-line.js

   1 /**
   2  * (C) Copyright 2007 John J. Foerch
   3  * (C) Copyright 2007-2008 Jeremy Maitin-Shepard
   4  *
   5  * Use, modification, and distribution are subject to the terms specified in the
   6  * COPYING file.
   7 **/
   8
   9 var command_line_handlers = [];
  10
  11 define_variable("url_remoting_fn", load_url_in_new_window);
  12
  13 /*
  14  * load_url_in_new_window is a function intended for use as
  15  * a value of `url_remoting_fn'.  Every url given on the
  16  * command line will be loaded in a new window.
  17  */
  18 function load_url_in_new_window(url, ctx) {
  19     make_window(buffer_creator(content_buffer, $load = url, $configuration = ctx.config));
  20 }
  21
  22 /*
  23  * load_url_in_new_buffer is a function intended for use as
  24  * a value of `url_remoting_fn'.  Every url given on the
  25  * command line will be loaded in a new buffer in the most
  26  * recently used window, or a new window if none exist.
  27  */
  28 function load_url_in_new_buffer(url, ctx) {
  29     create_buffer_in_current_window(buffer_creator(content_buffer, $load = url, $configuration = ctx.config),
  30                                     OPEN_NEW_BUFFER, true /* focus the new window */);
  31 }
  32
  33 /*
  34  * load_url_in_current_buffer is a function intended for use
  35  * as a value of `url_remoting_fn'.  Every url given on the
  36  * command line will be loaded in the current buffer of the
  37  * most recently used window.  This makes it useful for only
  38  * one url at a time.  When there are no conkeror windows
  39  * open, the url will be loaded in a new window.
  40  */
  41 function  load_url_in_current_buffer(url,ctx) {
  42     var win = get_recent_conkeror_window();
  43     if (win) {
  44         browser_object_follow(win.buffers.current, OPEN_CURRENT_BUFFER, url);
  45     } else {
  46         load_url_in_new_window(url, ctx);
  47     }
  48 }
  49
  50 function command_line_handler(name, suppress_default, handler)
  51 {
  52     command_line_handlers[name] = { suppress_default: suppress_default, func: handler };
  53 }
  54
  55 function command_line_param_handler(name, suppress_default, handler)
  56 {
  57     command_line_handlers[name] = { suppress_default: suppress_default,
  58                                     param: true,
  59                                     func: handler };
  60 }
  61
  62 command_line_handler("batch", true);
  63 command_line_param_handler("e", true, function (expr, ctx) {
  64         eval(expr);
  65     });
  66
  67 command_line_param_handler("E", false, function (expr, ctx) {});
  68
  69 command_line_param_handler("chrome", true, function (uri, ctx) {
  70         try {
  71             make_chrome_window(uri);
  72         } catch (e) { dump_error(e); }
  73     });
  74 command_line_param_handler("q", false, function () {
  75         dumpln ("w: -q may only be used as the first argument.");
  76     });
  77
  78 command_line_param_handler("cwd", false, function (dir, ctx) {
  79         if (ctx.config == null)
  80             ctx.config = {};
  81         ctx.config.cwd = dir;
  82     });
  83
  84 command_line_param_handler("f", true, function (command, ctx) {
  85         ctx.window = window_watcher.activeWindow;
  86         call_interactively(ctx, command);
  87     });
  88
  89 command_line_param_handler("l", false, function (path, ctx) {
  90         try {
  91             load_rc(ctx.command_line.resolveFile(path).path);
  92         } catch (e) { dump_error(e);  }
  93     });
  94
  95 command_line_handler("uu", false, function (ctx) {
  96         if (! ctx.window)
  97             ctx.window = window_watcher.activeWindow;
  98         call_interactively(ctx, "universal-argument");
  99     });
 100
 101 function handle_command_line(cmdline)
 102 {
 103     try {
 104         var suppress_default = false;
 105         var suppress_rc = false;
 106
 107         var i = 0;
 108
 109         /* -q must be the first argument, if it is given */
 110         if (cmdline.length > 0 && cmdline.getArgument(0) == "-q")
 111         {
 112             suppress_rc = true;
 113             i++;
 114         }
 115
 116         var initial_launch = (cmdline.state == cmdline.STATE_INITIAL_LAUNCH);
 117
 118         if (initial_launch) {
 119             let j = i;
 120             while (j + 1 < cmdline.length) {
 121                 if (cmdline.getArgument(j) == "-E") {
 122                     eval(cmdline.getArgument(j+1));
 123                     cmdline.removeArguments(j, j+1);
 124                 } else
 125                     ++j;
 126             }
 127
 128             let load_default_modules = get_pref("conkeror.loadDefaultModules");
 129             let load_mods = new RegExp("^(" + get_pref("conkeror.loadModules") + ")$");
 130             try {
 131                 let branch = preferences.getBranch("conkeror.load.");
 132                 for each (let m in branch.getChildList("", {})) {
 133                     let val;
 134                     try {
 135                         val = branch.getIntPref(m);
 136                     } catch (e) {
 137                         dumpln("Error: Preference 'conkeror.load." + m + "' has non-integer value.");
 138                     }
 139                     if ((val > 0 && (load_default_modules > 0 ||
 140                                      ((load_default_modules == 0) && branch.prefHasUserValue(m)))) ||
 141                         (val >= 0 && load_mods.test(m)))
 142                         require(m + ".js");
 143                 }
 144             } catch (e) {dump_error(e);}
 145         }
 146
 147         if (! suppress_rc && initial_launch)
 148         {
 149             try {
 150                 load_rc ();
 151             } catch (e) { dump (e + "\n"); }
 152         } else if (suppress_rc && ! initial_launch) {
 153             dumpln ("w: attempt to suppress load_rc in remote invocation");
 154         }
 155         var ctx = {command_line: cmdline}; // command-line processing context
 156
 157         for (; i < cmdline.length; ++i)
 158         {
 159             var arg = cmdline.getArgument(i);
 160             if (arg[0] == '-') {
 161                 var arg1 = arg.substring(1);
 162                 if (arg1 in command_line_handlers) {
 163                     var handler = command_line_handlers[arg1];
 164                     if (handler.suppress_default)
 165                         suppress_default = true;
 166                     if (handler.func) {
 167                         if (handler.param) {
 168                             i++; // increment the argument counter to skip the parameter
 169                             if (i >= cmdline.length) {
 170                                 dump ("w: ignoring command switch `"+arg+"' because no argument was provided.\n");
 171                                 continue;
 172                             }
 173                             var param = cmdline.getArgument (i);
 174                             handler.func(param, ctx);
 175                         } else {
 176                             handler.func(ctx);
 177                         }
 178                     }
 179                     continue;
 180                 } else {
 181                     dump ("w: unknown command switch `"+arg+"'.\n");
 182                 }
 183             } else {
 184                 // something other than a switch was passed on the command
 185                 // line.  suppress the default window, and call the
 186                 // user-configurable remoting function on it.
 187                 //
 188                 suppress_default = true;
 189                 url_remoting_fn (arg, ctx);
 190             }
 191         }
 192
 193         // we are greedy and handle all command line arguments.  remove
 194         // everything from the command line object, so no other
 195         // components can see them.
 196         //
 197         if (cmdline.length > 0) {
 198             cmdline.removeArguments(0, cmdline.length - 1);
 199         }
 200
 201         // no args were found for url_remoting_fn, and no switches
 202         // explicitly suppressed the creation of a default window
 203         // (e.g. -batch or -daemon)
 204         //
 205         if (! suppress_default) {
 206             url_remoting_fn(homepage, ctx);
 207         }
 208     } catch (e) {
 209         dumpln("Error processing command line.");
 210         dump_error(e);
 211     }
 212 }
 213