src/dosfns.c

   1 /* MS-DOS specific Lisp utilities.  Coded by Manabu Higashida, 1991.
   2    Major changes May-July 1993 Morten Welinder (only 10% original code left)
   3    Copyright (C) 1991, 1993, 1996-1998, 2001-2012 Free Software Foundation, Inc.
   4
   5 This file is part of GNU Emacs.
   6
   7 GNU Emacs is free software: you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation, either version 3 of the License, or
  10 (at your option) any later version.
  11
  12 GNU Emacs is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include <config.h>
  21
  22 #ifdef MSDOS
  23 /* The entire file is within this conditional */
  24
  25 #include <stdio.h>
  26 /* gettime and settime in dos.h clash with their namesakes from
  27    gnulib, so we move out of our way the prototypes in dos.h.  */
  28 #define gettime dos_h_gettime_
  29 #define settime dos_h_settime_
  30 #include <dos.h>
  31 #undef gettime
  32 #undef settime
  33 #include <setjmp.h>
  34 #include "lisp.h"
  35 #include "character.h"
  36 #include "buffer.h"
  37 #include "termchar.h"
  38 #include "frame.h"
  39 #include "termhooks.h"
  40 #include "blockinput.h"
  41 #include "window.h"
  42 #include "dosfns.h"
  43 #include "msdos.h"
  44 #include "dispextern.h"
  45 #include "coding.h"
  46 #include "process.h"
  47 #include <dpmi.h>
  48 #include <go32.h>
  49 #include <dirent.h>
  50 #include <sys/vfs.h>
  51 #include <unistd.h>
  52 #include <grp.h>
  53 #include <crt0.h>
  54
  55 DEFUN ("int86", Fint86, Sint86, 2, 2, 0,
  56        doc: /* Call specific MS-DOS interrupt number INTERRUPT with REGISTERS.
  57 Return the updated REGISTER vector.
  58
  59 INTERRUPT should be an integer in the range 0 to 255.
  60 REGISTERS should be a vector produced by `make-register' and
  61 `set-register-value'.  */)
  62   (Lisp_Object interrupt, Lisp_Object registers)
  63 {
  64   register int i;
  65   int no;
  66   union REGS inregs, outregs;
  67
  68   CHECK_NUMBER (interrupt);
  69   no = (unsigned long) XINT (interrupt);
  70   CHECK_VECTOR (registers);
  71   if (no < 0 || no > 0xff || ASIZE (registers) != 8)
  72     return Qnil;
  73   for (i = 0; i < 8; i++)
  74     CHECK_NUMBER (AREF (registers, i));
  75
  76   inregs.x.ax    = (unsigned long) XFASTINT (AREF (registers, 0));
  77   inregs.x.bx    = (unsigned long) XFASTINT (AREF (registers, 1));
  78   inregs.x.cx    = (unsigned long) XFASTINT (AREF (registers, 2));
  79   inregs.x.dx    = (unsigned long) XFASTINT (AREF (registers, 3));
  80   inregs.x.si    = (unsigned long) XFASTINT (AREF (registers, 4));
  81   inregs.x.di    = (unsigned long) XFASTINT (AREF (registers, 5));
  82   inregs.x.cflag = (unsigned long) XFASTINT (AREF (registers, 6));
  83   inregs.x.flags = (unsigned long) XFASTINT (AREF (registers, 7));
  84
  85   int86 (no, &inregs, &outregs);
  86
  87   ASET (registers, 0, make_number (outregs.x.ax));
  88   ASET (registers, 1, make_number (outregs.x.bx));
  89   ASET (registers, 2, make_number (outregs.x.cx));
  90   ASET (registers, 3, make_number (outregs.x.dx));
  91   ASET (registers, 4, make_number (outregs.x.si));
  92   ASET (registers, 5, make_number (outregs.x.di));
  93   ASET (registers, 6, make_number (outregs.x.cflag));
  94   ASET (registers, 7, make_number (outregs.x.flags));
  95
  96   return registers;
  97 }
  98
  99 DEFUN ("msdos-memget", Fdos_memget, Sdos_memget, 2, 2, 0,
 100        doc: /* Read DOS memory at offset ADDRESS into VECTOR.
 101 Return the updated VECTOR.  */)
 102   (Lisp_Object address, Lisp_Object vector)
 103 {
 104   register int i;
 105   int offs, len;
 106   char *buf;
 107
 108   CHECK_NUMBER (address);
 109   offs = (unsigned long) XINT (address);
 110   CHECK_VECTOR (vector);
 111   len = ASIZE (vector);
 112   if (len < 1 || len > 2048 || offs < 0 || offs > 0xfffff - len)
 113     return Qnil;
 114   buf = alloca (len);
 115   dosmemget (offs, len, buf);
 116
 117   for (i = 0; i < len; i++)
 118     ASET (vector, i, make_number (buf[i]));
 119
 120   return vector;
 121 }
 122
 123 DEFUN ("msdos-memput", Fdos_memput, Sdos_memput, 2, 2, 0,
 124        doc: /* Write DOS memory at offset ADDRESS from VECTOR.  */)
 125   (Lisp_Object address, Lisp_Object vector)
 126 {
 127   register int i;
 128   int offs, len;
 129   char *buf;
 130
 131   CHECK_NUMBER (address);
 132   offs = (unsigned long) XINT (address);
 133   CHECK_VECTOR (vector);
 134   len = ASIZE (vector);
 135   if (len < 1 || len > 2048 || offs < 0 || offs > 0xfffff - len)
 136     return Qnil;
 137   buf = alloca (len);
 138
 139   for (i = 0; i < len; i++)
 140     {
 141       CHECK_NUMBER (AREF (vector, i));
 142       buf[i] = (unsigned char) XFASTINT (AREF (vector, i)) & 0xFF;
 143     }
 144
 145   dosmemput (buf, len, offs);
 146   return Qt;
 147 }
 148
 149 DEFUN ("msdos-set-keyboard", Fmsdos_set_keyboard, Smsdos_set_keyboard, 1, 2, 0,
 150        doc: /* Set keyboard layout according to COUNTRY-CODE.
 151 If the optional argument ALLKEYS is non-nil, the keyboard is mapped for
 152 all keys; otherwise it is only used when the ALT key is pressed.
 153 The current keyboard layout is available in dos-keyboard-code.  */)
 154   (Lisp_Object country_code, Lisp_Object allkeys)
 155 {
 156   CHECK_NUMBER (country_code);
 157   if (!dos_set_keyboard (XINT (country_code), !NILP (allkeys)))
 158     return Qnil;
 159   return Qt;
 160 }
 161
 162 #ifndef HAVE_X_WINDOWS
 163 /* Later we might want to control the mouse interface with this function,
 164    e.g., with respect to non-80 column screen modes.  */
 165
 166 DEFUN ("msdos-mouse-p", Fmsdos_mouse_p, Smsdos_mouse_p, 0, 0, 0,
 167        doc: /* Report whether a mouse is present.  */)
 168   (void)
 169 {
 170   if (have_mouse)
 171     return Qt;
 172   else
 173     return Qnil;
 174 }
 175 #endif
 176
 177 DEFUN ("msdos-mouse-init", Fmsdos_mouse_init, Smsdos_mouse_init, 0, 0, "",
 178        doc: /* Initialize and enable mouse if available.  */)
 179   (void)
 180 {
 181   if (have_mouse)
 182     {
 183       have_mouse = 1;
 184       mouse_init ();
 185       return Qt;
 186     }
 187   return Qnil;
 188 }
 189
 190 DEFUN ("msdos-mouse-enable", Fmsdos_mouse_enable, Smsdos_mouse_enable, 0, 0, "",
 191        doc: /* Enable mouse if available.  */)
 192   (void)
 193 {
 194   if (have_mouse)
 195     {
 196       have_mouse = 1;
 197       mouse_on ();
 198     }
 199   return have_mouse ? Qt : Qnil;
 200 }
 201
 202 DEFUN ("msdos-mouse-disable", Fmsdos_mouse_disable, Smsdos_mouse_disable, 0, 0, "",
 203        doc: /* Disable mouse if available.  */)
 204   (void)
 205 {
 206   mouse_off ();
 207   if (have_mouse) have_mouse = -1;
 208   return Qnil;
 209 }
 210
 211 DEFUN ("insert-startup-screen", Finsert_startup_screen, Sinsert_startup_screen, 0, 0, "",
 212        doc: /* Insert copy of screen contents prior to starting Emacs.
 213 Return nil if startup screen is not available.  */)
 214   (void)
 215 {
 216   char *s;
 217   int rows, cols, i, j;
 218
 219   if (!dos_get_saved_screen (&s, &rows, &cols))
 220     return Qnil;
 221
 222   for (i = 0; i < rows; i++)
 223     {
 224       for (j = 0; j < cols; j++)
 225         {
 226           insert_char (*s);
 227           s += 2;
 228         }
 229       insert_char ('\n');
 230     }
 231
 232   return Qt;
 233 }
 234 \f
 235 unsigned char dos_country_info[DOS_COUNTRY_INFO];
 236 static unsigned char usa_country_info[DOS_COUNTRY_INFO] = {
 237   0, 0,                         /* date format */
 238   '$', 0, 0, 0, 0,              /* currency string */
 239   ',', 0,                       /* thousands separator */
 240   '.', 0,                       /* decimal separator */
 241   '/', 0,                       /* date separator */
 242   ':', 0,                       /* time separator */
 243   0,                            /* currency format */
 244   2,                            /* digits after decimal in currency */
 245   0,                            /* time format */
 246   0, 0, 0, 0,                   /* address of case map routine, GPF if used */
 247   ' ', 0,                       /* data-list separator (?) */
 248   0, 0, 0, 0, 0, 0, 0, 0, 0, 0  /* reserved */
 249 };
 250
 251 #ifndef HAVE_X_WINDOWS
 252 static unsigned dos_windows_version;
 253 char parent_vm_title[50];       /* Ralf Brown says 30 is enough */
 254 int w95_set_virtual_machine_title (const char *);
 255
 256 void
 257 restore_parent_vm_title (void)
 258 {
 259   if (NILP (Vdos_windows_version))
 260     return;
 261   if ((dos_windows_version & 0xff) >= 4 && parent_vm_title[0])
 262     w95_set_virtual_machine_title (parent_vm_title);
 263   delay (50);
 264 }
 265 #endif /* !HAVE_X_WINDOWS */
 266
 267 void
 268 init_dosfns (void)
 269 {
 270   union REGS regs;
 271   _go32_dpmi_registers dpmiregs;
 272   unsigned long xbuf = _go32_info_block.linear_address_of_transfer_buffer;
 273
 274 #ifndef SYSTEM_MALLOC
 275   extern void get_lim_data (void);
 276
 277   get_lim_data (); /* why the hell isn't this called elsewhere? */
 278 #endif
 279
 280   regs.x.ax = 0x3000;
 281   intdos (&regs, &regs);
 282   Vdos_version = Fcons (make_number (regs.h.al), make_number (regs.h.ah));
 283
 284   /* Obtain the country code via DPMI, use DJGPP transfer buffer.  */
 285   dpmiregs.x.ax = 0x3800;
 286   dpmiregs.x.ds = xbuf >> 4;
 287   dpmiregs.x.dx = 0;
 288   dpmiregs.x.ss = dpmiregs.x.sp = dpmiregs.x.flags = 0;
 289   _go32_dpmi_simulate_int (0x21, &dpmiregs);
 290   if (dpmiregs.x.flags & 1)
 291     {
 292       dos_country_code = 1;     /* assume USA if 213800 failed */
 293       memcpy (dos_country_info, usa_country_info, DOS_COUNTRY_INFO);
 294     }
 295   else
 296     {
 297       dos_country_code = dpmiregs.x.bx;
 298       dosmemget (xbuf, DOS_COUNTRY_INFO, dos_country_info);
 299     }
 300
 301   dos_set_keyboard (dos_country_code, 0);
 302
 303   regs.x.ax = 0x6601;
 304   intdos (&regs, &regs);
 305   if (regs.x.cflag)
 306     /* Estimate code page from country code */
 307     switch (dos_country_code)
 308       {
 309       case 45: /* Denmark */
 310       case 47: /* Norway */
 311         dos_codepage = 865;
 312         break;
 313       default:
 314         /* US */
 315         dos_codepage = 437;
 316       }
 317   else
 318     dos_codepage = regs.x.bx & 0xffff;
 319
 320 #ifndef HAVE_X_WINDOWS
 321   parent_vm_title[0] = '\0';
 322
 323   /* If we are running from DOS box on MS-Windows, get Windows version.  */
 324   dpmiregs.x.ax = 0x1600;       /* enhanced mode installation check */
 325   dpmiregs.x.ss = dpmiregs.x.sp = dpmiregs.x.flags = 0;
 326   _go32_dpmi_simulate_int (0x2f, &dpmiregs);
 327   /* We only support Windows-specific features when we run on Windows 9X
 328      or on Windows 3.X/enhanced mode.
 329
 330      Int 2Fh/AX=1600h returns:
 331
 332      AL = 00:  no Windows at all;
 333      AL = 01:  Windows/386 2.x;
 334      AL = 80h: Windows 3.x in mode other than enhanced;
 335      AL = FFh: Windows/386 2.x
 336
 337      We also check AH > 0 (Windows 3.1 or later), in case AL tricks us.  */
 338   if (dpmiregs.h.al > 2 && dpmiregs.h.al != 0x80 && dpmiregs.h.al != 0xff
 339       && (dpmiregs.h.al > 3 || dpmiregs.h.ah > 0))
 340     {
 341       dos_windows_version = dpmiregs.x.ax;
 342       Vdos_windows_version =
 343         Fcons (make_number (dpmiregs.h.al), make_number (dpmiregs.h.ah));
 344
 345       /* Save the current title of this virtual machine, so we can restore
 346          it before exiting.  Otherwise, Windows 95 will continue to use
 347          the title we set even after we are history, stupido...  */
 348       if (dpmiregs.h.al >= 4)
 349         {
 350           dpmiregs.x.ax = 0x168e;
 351           dpmiregs.x.dx = 3;    /* get VM title */
 352           dpmiregs.x.cx = sizeof (parent_vm_title) - 1;
 353           dpmiregs.x.es = __tb >> 4;
 354           dpmiregs.x.di = __tb & 15;
 355           dpmiregs.x.sp = dpmiregs.x.ss = dpmiregs.x.flags = 0;
 356           _go32_dpmi_simulate_int (0x2f, &dpmiregs);
 357           if (dpmiregs.x.ax == 1)
 358             dosmemget (__tb, sizeof (parent_vm_title), parent_vm_title);
 359         }
 360     }
 361   else
 362     {
 363       dos_windows_version = 0;
 364       Vdos_windows_version = Qnil;
 365     }
 366 #endif /* !HAVE_X_WINDOWS */
 367
 368   /* Without this, we never see hidden files.
 369      Don't OR it with the previous value, so the value recorded at dump
 370      time, possibly with `preserve-case' flags set, won't get through.  */
 371   __opendir_flags = __OPENDIR_FIND_HIDDEN;
 372
 373 #if __DJGPP_MINOR__ == 0
 374   /* Under LFN, preserve the case of files as recorded in the directory
 375      (in DJGPP 2.01 and later this is automagically done by the library).  */
 376   if (!NILP (Fmsdos_long_file_names ()))
 377     __opendir_flags |= __OPENDIR_PRESERVE_CASE;
 378 #endif /* __DJGPP_MINOR__ == 0 */
 379 }
 380 \f
 381 #ifndef HAVE_X_WINDOWS
 382
 383 /* Emulation of some X window features from xfns.c and xfaces.c.  */
 384
 385 /* Standard VGA colors, in the order of their standard numbering
 386    in the default VGA palette.  */
 387 static char *vga_colors[16] = {
 388   "black", "blue", "green", "cyan", "red", "magenta", "brown",
 389   "lightgray", "darkgray", "lightblue", "lightgreen", "lightcyan",
 390   "lightred", "lightmagenta", "yellow", "white"
 391 };
 392
 393 /* Given a color name, return its index, or -1 if not found.  Note
 394    that this only performs case-insensitive comparison against the
 395    standard names.  For anything more sophisticated, like matching
 396    "gray" with "grey" or translating X color names into their MSDOS
 397    equivalents, call the Lisp function Qtty_color_desc (defined
 398    on lisp/term/tty-colors.el).  */
 399 int
 400 msdos_stdcolor_idx (const char *name)
 401 {
 402   int i;
 403
 404   for (i = 0; i < sizeof (vga_colors) / sizeof (vga_colors[0]); i++)
 405     if (xstrcasecmp (name, vga_colors[i]) == 0)
 406       return i;
 407
 408   return
 409     strcmp (name, unspecified_fg) == 0 ? FACE_TTY_DEFAULT_FG_COLOR
 410     : strcmp (name, unspecified_bg) == 0 ? FACE_TTY_DEFAULT_BG_COLOR
 411     : FACE_TTY_DEFAULT_COLOR;
 412 }
 413
 414 /* Given a color index, return its standard name.  */
 415 Lisp_Object
 416 msdos_stdcolor_name (int idx)
 417 {
 418   extern Lisp_Object Qunspecified;
 419
 420   if (idx == FACE_TTY_DEFAULT_FG_COLOR)
 421     return build_string (unspecified_fg);
 422   else if (idx == FACE_TTY_DEFAULT_BG_COLOR)
 423     return build_string (unspecified_bg);
 424   else if (idx >= 0 && idx < sizeof (vga_colors) / sizeof (vga_colors[0]))
 425     return build_string (vga_colors[idx]);
 426   else
 427     return Qunspecified;        /* meaning the default */
 428 }
 429
 430 /* Support for features that are available when we run in a DOS box
 431    on MS-Windows.  */
 432 int
 433 ms_windows_version (void)
 434 {
 435   return dos_windows_version;
 436 }
 437
 438 /* Set the title of the current virtual machine, to appear on
 439    the caption bar of that machine's window.  */
 440
 441 int
 442 w95_set_virtual_machine_title (const char *title_string)
 443 {
 444   /* Only Windows 9X (version 4 and higher) support this function.  */
 445   if (!NILP (Vdos_windows_version)
 446       && (dos_windows_version & 0xff) >= 4)
 447     {
 448       _go32_dpmi_registers regs;
 449       dosmemput (title_string, strlen (title_string) + 1, __tb);
 450       regs.x.ax = 0x168e;
 451       regs.x.dx = 1;
 452       regs.x.es = __tb >> 4;
 453       regs.x.di = __tb & 15;
 454       regs.x.sp = regs.x.ss = regs.x.flags = 0;
 455       _go32_dpmi_simulate_int (0x2f, &regs);
 456       return regs.x.ax == 1;
 457     }
 458   return 0;
 459 }
 460
 461 /* Change the title of frame F to NAME.
 462    If NAME is nil, use the frame name as the title.
 463
 464    If Emacs is not run from a DOS box on Windows 9X, this only
 465    sets the name in the frame struct, but has no other effects.  */
 466
 467 void
 468 x_set_title (struct frame *f, Lisp_Object name)
 469 {
 470   /* Don't change the title if it's already NAME.  */
 471   if (EQ (name, f->title))
 472     return;
 473
 474   update_mode_lines = 1;
 475
 476   f->title = name;
 477
 478   if (NILP (name))
 479     name = f->name;
 480
 481   if (FRAME_MSDOS_P (f))
 482     {
 483       BLOCK_INPUT;
 484       w95_set_virtual_machine_title (SDATA (name));
 485       UNBLOCK_INPUT;
 486     }
 487 }
 488 #endif /* !HAVE_X_WINDOWS */
 489 \f
 490 DEFUN ("file-system-info", Ffile_system_info, Sfile_system_info, 1, 1, 0,
 491        doc: /* Return storage information about the file system FILENAME is on.
 492 Value is a list of floats (TOTAL FREE AVAIL), where TOTAL is the total
 493 storage of the file system, FREE is the free storage, and AVAIL is the
 494 storage available to a non-superuser.  All 3 numbers are in bytes.
 495 If the underlying system call fails, value is nil.  */)
 496   (Lisp_Object filename)
 497 {
 498   struct statfs stfs;
 499   Lisp_Object encoded, value;
 500
 501   CHECK_STRING (filename);
 502   filename = Fexpand_file_name (filename, Qnil);
 503   encoded = ENCODE_FILE (filename);
 504
 505   if (statfs (SDATA (encoded), &stfs))
 506     value = Qnil;
 507   else
 508     value = list3 (make_float ((double) stfs.f_bsize * stfs.f_blocks),
 509                    make_float ((double) stfs.f_bsize * stfs.f_bfree),
 510                    make_float ((double) stfs.f_bsize * stfs.f_bavail));
 511
 512   return value;
 513 }
 514 \f
 515 /* System depended enumeration of and access to system processes a-la
 516    ps(1).  Here, we only return info about the running Emacs process.
 517    (There are no other processes on DOS, right?)  */
 518
 519 Lisp_Object
 520 list_system_processes (void)
 521 {
 522   Lisp_Object proclist = Qnil;
 523
 524   proclist = Fcons (make_fixnum_or_float (getpid ()), proclist);
 525
 526   return proclist;
 527 }
 528
 529 Lisp_Object
 530 system_process_attributes (Lisp_Object pid)
 531 {
 532   int proc_id;
 533   Lisp_Object attrs = Qnil;
 534
 535   CHECK_NUMBER_OR_FLOAT (pid);
 536   proc_id = FLOATP (pid) ? XFLOAT_DATA (pid) : XINT (pid);
 537
 538   if (proc_id == getpid ())
 539     {
 540       EMACS_INT uid, gid;
 541       char *usr;
 542       struct group *gr;
 543       char cmd[FILENAME_MAX];
 544       char *cmdline = NULL, *p, *q;
 545       size_t cmdline_size = 0;
 546       int i;
 547       Lisp_Object cmd_str, decoded_cmd, tem;
 548       double pmem;
 549 #ifndef SYSTEM_MALLOC
 550       extern unsigned long ret_lim_data ();
 551 #endif
 552
 553       uid = getuid ();
 554       attrs = Fcons (Fcons (Qeuid, make_fixnum_or_float (uid)), attrs);
 555       usr = getlogin ();
 556       if (usr)
 557         attrs = Fcons (Fcons (Quser, build_string (usr)), attrs);
 558       gid = getgid ();
 559       attrs = Fcons (Fcons (Qegid, make_fixnum_or_float (gid)), attrs);
 560       gr = getgrgid (gid);
 561       if (gr)
 562         attrs = Fcons (Fcons (Qgroup, build_string (gr->gr_name)), attrs);
 563       strcpy (cmd, basename (__crt0_argv[0]));
 564       /* Command name is encoded in locale-coding-system; decode it.  */
 565       cmd_str = build_unibyte_string (cmd);
 566       decoded_cmd = code_convert_string_norecord (cmd_str,
 567                                                   Vlocale_coding_system, 0);
 568       attrs = Fcons (Fcons (Qcomm, decoded_cmd), attrs);
 569       /* Pretend we have 0 as PPID.  */
 570       attrs = Fcons (Fcons (Qppid, make_number (0)), attrs);
 571       attrs = Fcons (Fcons (Qpgrp, pid), attrs);
 572       attrs = Fcons (Fcons (Qttname, build_string ("/dev/tty")), attrs);
 573       /* We are never idle!  */
 574       tem = Fget_internal_run_time ();
 575       attrs = Fcons (Fcons (Qtime, tem), attrs);
 576       attrs = Fcons (Fcons (Qthcount, make_number (1)), attrs);
 577       attrs = Fcons (Fcons (Qstart,
 578                             Fsymbol_value (intern ("before-init-time"))),
 579                      attrs);
 580       attrs = Fcons (Fcons (Qvsize,
 581                             make_fixnum_or_float ((unsigned long)sbrk (0)/1024)),
 582                      attrs);
 583       attrs = Fcons (Fcons (Qetime, tem), attrs);
 584 #ifndef SYSTEM_MALLOC
 585       /* ret_lim_data is on vm-limit.c, which is not compiled in under
 586          SYSTEM_MALLOC.  */
 587       pmem = (double)((unsigned long) sbrk (0)) / ret_lim_data () * 100.0;
 588       if (pmem > 100)
 589 #endif
 590         pmem = 100;
 591       attrs = Fcons (Fcons (Qpmem, make_float (pmem)), attrs);
 592       /* Pass 1: Count how much storage we need.  */
 593       for (i = 0; i < __crt0_argc; i++)
 594         {
 595           cmdline_size += strlen (__crt0_argv[i]) + 1; /* +1 for blank delim */
 596           if (strpbrk (__crt0_argv[i], " \t\n\r\v\f"))
 597             {
 598               cmdline_size += 2;
 599               for (p = __crt0_argv[i]; *p; p++)
 600                 {
 601                   if (*p == '"')
 602                     cmdline_size++;
 603                 }
 604             }
 605         }
 606       /* Pass 2: Allocate storage and concatenate argv[].  */
 607       cmdline = xmalloc (cmdline_size + 1);
 608       for (i = 0, q = cmdline; i < __crt0_argc; i++)
 609         {
 610           if (strpbrk (__crt0_argv[i], " \t\n\r\v\f"))
 611             {
 612               *q++ = '"';
 613               for (p = __crt0_argv[i]; *p; p++)
 614                 {
 615                   if (*p == '\"')
 616                     *q++ = '\\';
 617                   *q++ = *p;
 618                 }
 619               *q++ = '"';
 620             }
 621           else
 622             {
 623               strcpy (q, __crt0_argv[i]);
 624               q += strlen (__crt0_argv[i]);
 625             }
 626           *q++ = ' ';
 627         }
 628       /* Remove the trailing blank.  */
 629       if (q > cmdline)
 630         q[-1] = '\0';
 631
 632       /* Command line is encoded in locale-coding-system; decode it.  */
 633       cmd_str = build_unibyte_string (cmdline);
 634       decoded_cmd = code_convert_string_norecord (cmd_str,
 635                                                   Vlocale_coding_system, 0);
 636       xfree (cmdline);
 637       attrs = Fcons (Fcons (Qargs, decoded_cmd), attrs);
 638     }
 639
 640   return attrs;
 641 }
 642 \f
 643 void
 644 dos_cleanup (void)
 645 {
 646   struct tty_display_info *tty;
 647
 648 #ifndef HAVE_X_WINDOWS
 649   restore_parent_vm_title ();
 650 #endif
 651   /* Make sure the termscript file is committed, in case we are
 652      crashing and some vital info was written there.  */
 653   if (FRAMEP (selected_frame))
 654     {
 655       struct frame *sf = XFRAME (selected_frame);
 656
 657       if (FRAME_LIVE_P (sf)
 658           && (FRAME_MSDOS_P (sf) || FRAME_TERMCAP_P (sf)))
 659         {
 660           tty = CURTTY ();
 661           if (tty->termscript)
 662             {
 663               fflush (tty->termscript);
 664               fsync (fileno (tty->termscript));
 665             }
 666         }
 667     }
 668 }
 669
 670 /*
 671  *      Define everything
 672  */
 673 void
 674 syms_of_dosfns (void)
 675 {
 676   defsubr (&Sint86);
 677   defsubr (&Sdos_memget);
 678   defsubr (&Sdos_memput);
 679   defsubr (&Smsdos_mouse_init);
 680   defsubr (&Smsdos_mouse_enable);
 681   defsubr (&Smsdos_set_keyboard);
 682   defsubr (&Sinsert_startup_screen);
 683   defsubr (&Smsdos_mouse_disable);
 684   defsubr (&Sfile_system_info);
 685 #ifndef HAVE_X_WINDOWS
 686   defsubr (&Smsdos_mouse_p);
 687 #endif
 688
 689   DEFVAR_INT ("dos-country-code", dos_country_code,
 690               doc: /* The country code returned by Dos when Emacs was started.
 691 Usually this is the international telephone prefix.  */);
 692
 693   DEFVAR_INT ("dos-codepage", dos_codepage,
 694               doc: /* The codepage active when Emacs was started.
 695 The following are known:
 696         437     United States
 697         850     Multilingual (Latin I)
 698         852     Slavic (Latin II)
 699         857     Turkish
 700         860     Portugal
 701         861     Iceland
 702         863     Canada (French)
 703         865     Norway/Denmark  */);
 704
 705   DEFVAR_INT ("dos-timezone-offset", dos_timezone_offset,
 706               doc: /* The current timezone offset to UTC in minutes.
 707 Implicitly modified when the TZ variable is changed.  */);
 708
 709   DEFVAR_LISP ("dos-version", Vdos_version,
 710                doc: /* The (MAJOR . MINOR) Dos version (subject to modification with setver).  */);
 711
 712 #ifndef HAVE_X_WINDOWS
 713   DEFVAR_LISP ("dos-windows-version", Vdos_windows_version,
 714                doc: /* The (MAJOR . MINOR) Windows version for DOS session on MS-Windows.  */);
 715 #endif
 716
 717   DEFVAR_LISP ("dos-display-scancodes", Vdos_display_scancodes,
 718                doc: /* Whether DOS raw keyboard events are displayed as you type.
 719 When non-nil, the keyboard scan-codes are displayed at the bottom right
 720 corner of the display (typically at the end of the mode line).
 721 The output format is: scan code:char code*modifiers.  */);
 722
 723   Vdos_display_scancodes = Qnil;
 724
 725   DEFVAR_INT ("dos-hyper-key", dos_hyper_key,
 726               doc: /* If set to 1, use right ALT key as hyper key.
 727 If set to 2, use right CTRL key as hyper key.  */);
 728   dos_hyper_key = 0;
 729
 730   DEFVAR_INT ("dos-super-key", dos_super_key,
 731               doc: /* If set to 1, use right ALT key as super key.
 732 If set to 2, use right CTRL key as super key.  */);
 733   dos_super_key = 0;
 734
 735   DEFVAR_INT ("dos-keypad-mode", dos_keypad_mode,
 736               doc: /* Controls what key code is returned by a key in the numeric keypad.
 737 The `numlock ON' action is only taken if no modifier keys are pressed.
 738 The value is an integer constructed by adding the following bits together:
 739
 740   0x00  Digit key returns digit    (if numlock ON)
 741   0x01  Digit key returns kp-digit (if numlock ON)
 742   0x02  Digit key returns M-digit  (if numlock ON)
 743   0x03  Digit key returns edit key (if numlock ON)
 744
 745   0x00  Grey key returns char      (if numlock ON)
 746   0x04  Grey key returns kp-key    (if numlock ON)
 747
 748   0x00  Digit key returns digit    (if numlock OFF)
 749   0x10  Digit key returns kp-digit (if numlock OFF)
 750   0x20  Digit key returns M-digit  (if numlock OFF)
 751   0x30  Digit key returns edit key (if numlock OFF)
 752
 753   0x00  Grey key returns char      (if numlock OFF)
 754   0x40  Grey key returns kp-key    (if numlock OFF)
 755
 756   0x200 ALT-0..ALT-9 in top-row produces shifted codes.  */);
 757   dos_keypad_mode = 0x75;
 758
 759   DEFVAR_INT ("dos-keyboard-layout", dos_keyboard_layout,
 760               doc: /* Contains the country code for the current keyboard layout.
 761 Use msdos-set-keyboard to select another keyboard layout.  */);
 762   dos_keyboard_layout = 1;      /* US */
 763
 764   DEFVAR_INT ("dos-decimal-point", dos_decimal_point,
 765               doc: /* The character to produce when kp-decimal key is pressed.
 766 If non-zero, this variable contains the character to be returned when the
 767 decimal point key in the numeric keypad is pressed when Num Lock is on.
 768 If zero, the decimal point key returns the country code specific value.  */);
 769   dos_decimal_point = 0;
 770 }
 771 #endif /* MSDOS */