src/w16select.c

   1 /* 16-bit Windows Selection processing for emacs on MS-Windows
   2    Copyright (C) 1996, 1997, 2001 Free Software Foundation.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Emacs is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs; see the file COPYING.  If not, write to
  18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21 /* These functions work by using WinOldAp interface.  WinOldAp
  22    (WINOLDAP.MOD) is a Microsoft Windows extension supporting
  23    "old" (character-mode) application access to Dynamic Data Exchange,
  24    menus, and the Windows clipboard.  */
  25
  26 /* Written by Dale P. Smith <dpsm@en.com>  */
  27 /* Adapted to DJGPP v1 by Eli Zaretskii <eliz@is.elta.co.il>  */
  28
  29 #ifdef MSDOS
  30
  31 #include <config.h>
  32 #include <string.h>
  33 #include <dpmi.h>
  34 #include <go32.h>
  35 #include <sys/farptr.h>
  36 #include "lisp.h"
  37 #include "dispextern.h" /* frame.h seems to want this */
  38 #include "frame.h"      /* Need this to get the X window of selected_frame */
  39 #include "blockinput.h"
  40 #include "buffer.h"
  41 #include "charset.h"
  42 #include "coding.h"
  43 #include "composite.h"
  44
  45 /* If ever some function outside this file will need to call any
  46    clipboard-related function, the following prototypes and constants
  47    should be put on a header file.  Right now, nobody else uses them.  */
  48
  49 #define CF_TEXT      0x01
  50 #define CF_BITMAP    0x02
  51 #define CF_METAFILE  0x03
  52 #define CF_SYLK      0x04
  53 #define CF_DIF       0x05
  54 #define CF_TIFF      0x06
  55 #define CF_OEMTEXT   0x07
  56 #define CF_DIBBITMAP 0x08
  57 #define CF_WINWRITE  0x80
  58 #define CF_DSPTEXT   0x81
  59 #define CF_DSPBITMAP 0x82
  60
  61 unsigned identify_winoldap_version (void);
  62 unsigned open_clipboard (void);
  63 unsigned empty_clipboard (void);
  64 unsigned set_clipboard_data (unsigned, void *, unsigned, int);
  65 unsigned get_clipboard_data_size (unsigned);
  66 unsigned get_clipboard_data (unsigned, void *, unsigned, int);
  67 unsigned close_clipboard (void);
  68 unsigned clipboard_compact (unsigned);
  69
  70 Lisp_Object QCLIPBOARD, QPRIMARY;
  71
  72 /* Coding system for communicating with other Windows programs via the
  73    clipboard.  */
  74 static Lisp_Object Vselection_coding_system;
  75
  76 /* Coding system for the next communicating with other Windows programs.  */
  77 static Lisp_Object Vnext_selection_coding_system;
  78
  79 /* The segment address and the size of the buffer in low
  80    memory used to move data between us and WinOldAp module.  */
  81 static struct {
  82   unsigned long size;
  83   unsigned short rm_segment;
  84 } clipboard_xfer_buf_info;
  85
  86 /* The last text we put into the clipboard.  This is used to prevent
  87    passing back our own text from the clipboard, instead of using the
  88    kill ring.  The former is undesirable because the clipboard data
  89    could be MULEtilated by inappropriately chosen
  90    (next-)selection-coding-system.  For this reason, we must store the
  91    text *after* it was encoded/Unix-to-DOS-converted.  */
  92 static unsigned char *last_clipboard_text;
  93
  94 /* The size of allocated storage for storing the clipboard data.  */
  95 static size_t clipboard_storage_size;
  96 \f
  97 /* Emulation of `__dpmi_int' and friends for DJGPP v1.x  */
  98
  99 #if __DJGPP__ < 2
 100
 101 typedef _go32_dpmi_registers __dpmi_regs;
 102 #define __tb      _go32_info_block.linear_address_of_transfer_buffer
 103 #define _dos_ds   _go32_info_block.selector_for_linear_memory
 104
 105 static int
 106 __dpmi_int (intno, regs)
 107      int intno;
 108      __dpmi_regs *regs;
 109 {
 110   regs->x.ss = regs->x.sp = regs->x.flags = 0;
 111   return _go32_dpmi_simulate_int (intno, regs);
 112 }
 113
 114 #endif /* __DJGPP__ < 2 */
 115 \f
 116 /* C functions to access the Windows 3.1x clipboard from DOS apps.
 117
 118    The information was obtained from the Microsoft Knowledge Base,
 119    article Q67675 and can be found at:
 120    http://www.microsoft.com/kb/developr/win_dk/q67675.htm  */
 121
 122 /* See also Ralf Brown's Interrupt List.
 123
 124    I also seem to remember reading about this in Dr. Dobbs Journal a
 125    while ago, but if you knew my memory...  :-)
 126
 127    Dale P. Smith <dpsm@en.com> */
 128
 129 /* Return the WinOldAp support version, or 0x1700 if not supported.  */
 130 unsigned
 131 identify_winoldap_version ()
 132 {
 133   __dpmi_regs regs;
 134
 135   /* Calls Int 2Fh/AX=1700h
 136      Return Values   AX == 1700H: Clipboard functions not available
 137                         <> 1700H: AL = Major version number
 138                                   AH = Minor version number */
 139   regs.x.ax = 0x1700;
 140   __dpmi_int(0x2f, &regs);
 141   return regs.x.ax;
 142 }
 143
 144 /* Open the clipboard, return non-zero if successfull.  */
 145 unsigned
 146 open_clipboard ()
 147 {
 148   __dpmi_regs regs;
 149
 150   /* Is WINOLDAP supported?  */
 151   /* Kludge alert!!  If WinOldAp is not supported, we return a 0,
 152      which is the same as ``Clipboard already open''.  Currently,
 153      this is taken as an error by all the functions that use
 154      `open_clipboard', but if somebody someday will use that ``open''
 155      clipboard, they will have interesting time debugging it...  */
 156   if (identify_winoldap_version () == 0x1700)
 157     return 0;
 158
 159   /* Calls Int 2Fh/AX=1701h
 160      Return Values   AX == 0: Clipboard already open
 161                         <> 0: Clipboard opened */
 162   regs.x.ax = 0x1701;
 163   __dpmi_int(0x2f, &regs);
 164   return regs.x.ax;
 165 }
 166
 167 /* Empty clipboard, return non-zero if successfull.  */
 168 unsigned
 169 empty_clipboard ()
 170 {
 171   __dpmi_regs regs;
 172
 173   /* Calls Int 2Fh/AX=1702h
 174      Return Values   AX == 0: Error occurred
 175                         <> 0: OK, Clipboard emptied */
 176   regs.x.ax = 0x1702;
 177   __dpmi_int(0x2f, &regs);
 178   return regs.x.ax;
 179 }
 180
 181 /* Ensure we have a buffer in low memory with enough memory for data
 182    of size WANT_SIZE.  Return the linear address of the buffer.  */
 183 static unsigned long
 184 alloc_xfer_buf (want_size)
 185      unsigned want_size;
 186 {
 187   __dpmi_regs regs;
 188
 189   /* If the usual DJGPP transfer buffer is large enough, use that.  */
 190   if (want_size <= _go32_info_block.size_of_transfer_buffer)
 191     return __tb & 0xfffff;
 192
 193   /* Don't even try to allocate more than 1MB of memory: DOS cannot
 194      possibly handle that (it will overflow the BX register below).  */
 195   if (want_size > 0xfffff)
 196     return 0;
 197
 198   /* Need size rounded up to the nearest paragraph, and in
 199      paragraph units (1 paragraph = 16 bytes).  */
 200   clipboard_xfer_buf_info.size = (want_size + 15) >> 4;
 201
 202   /* The NT DPMI host crashes us if we free DOS memory via the
 203      DPMI service.  Work around by calling DOS allocate/free block.  */
 204   regs.h.ah = 0x48;
 205   regs.x.bx = clipboard_xfer_buf_info.size;
 206   __dpmi_int (0x21, &regs);
 207   if (regs.x.flags & 1)
 208     {
 209       clipboard_xfer_buf_info.size = 0;
 210       return 0;
 211     }
 212
 213   clipboard_xfer_buf_info.rm_segment = regs.x.ax;
 214   return (((int)clipboard_xfer_buf_info.rm_segment) << 4) & 0xfffff;
 215 }
 216
 217 /* Free our clipboard buffer.  We always free it after use, because
 218    keeping it leaves less free conventional memory for subprocesses.
 219    The clipboard buffer tends to be large in size, because for small
 220    clipboard data sizes we use the DJGPP transfer buffer.  */
 221 static void
 222 free_xfer_buf ()
 223 {
 224   /* If the size is 0, we used DJGPP transfer buffer, so don't free.  */
 225   if (clipboard_xfer_buf_info.size)
 226     {
 227       __dpmi_regs regs;
 228
 229       /* The NT DPMI host crashes us if we free DOS memory via
 230          the DPMI service.  Work around by calling DOS free block.  */
 231       regs.h.ah = 0x49;
 232       regs.x.es = clipboard_xfer_buf_info.rm_segment;
 233       __dpmi_int (0x21, &regs);
 234       clipboard_xfer_buf_info.size = 0;
 235     }
 236 }
 237
 238 /* Copy data into the clipboard, return zero if successfull.  */
 239 unsigned
 240 set_clipboard_data (Format, Data, Size, Raw)
 241      unsigned Format;
 242      void *Data;
 243      unsigned Size;
 244      int Raw;
 245 {
 246   __dpmi_regs regs;
 247   unsigned truelen;
 248   unsigned long xbuf_addr, buf_offset;
 249   unsigned char *dp = Data, *dstart = dp;
 250
 251   if (Format != CF_OEMTEXT)
 252     return 3;
 253
 254   /* need to know final size after '\r' chars are inserted (the
 255      standard CF_OEMTEXT clipboard format uses CRLF line endings,
 256      while Emacs uses just LF internally).  */
 257   truelen = Size + 1;           /* +1 for the terminating null */
 258
 259   if (!Raw)
 260     {
 261       /* avoid using strchr because it recomputes the length everytime */
 262       while ((dp = memchr (dp, '\n', Size - (dp - dstart))) != 0)
 263         {
 264           truelen++;
 265           dp++;
 266         }
 267     }
 268
 269   if (clipboard_compact (truelen) < truelen)
 270     return 1;
 271
 272   if ((xbuf_addr = alloc_xfer_buf (truelen)) == 0)
 273     return 1;
 274
 275   /* Move the buffer into the low memory, convert LF into CR-LF if needed.  */
 276   if (Raw)
 277     {
 278       dosmemput (Data, Size, xbuf_addr);
 279
 280       /* Terminate with a null, otherwise Windows does strange things
 281          when the text size is an integral multiple of 32 bytes. */
 282       _farpokeb (_dos_ds, xbuf_addr + Size, '\0');
 283     }
 284   else
 285     {
 286       dp = Data;
 287       buf_offset = xbuf_addr;
 288       _farsetsel (_dos_ds);
 289       while (Size--)
 290         {
 291           /* Don't allow them to put binary data into the clipboard, since
 292              it will cause yanked data to be truncated at the first null.  */
 293           if (*dp == '\0')
 294             return 2;
 295           if (*dp == '\n')
 296             _farnspokeb (buf_offset++, '\r');
 297           _farnspokeb (buf_offset++, *dp++);
 298         }
 299
 300       /* Terminate with a null, otherwise Windows does strange things
 301          when the text size is an integral multiple of 32 bytes. */
 302       _farnspokeb (buf_offset, '\0');
 303     }
 304
 305   /* Stash away the data we are about to put into the clipboard, so we
 306      could later check inside get_clipboard_data whether the clipboard
 307      still holds our data.  */
 308   if (clipboard_storage_size < truelen)
 309     {
 310       clipboard_storage_size = truelen + 100;
 311       last_clipboard_text =
 312         (char *) xrealloc (last_clipboard_text, clipboard_storage_size);
 313     }
 314   if (last_clipboard_text)
 315     dosmemget (xbuf_addr, truelen, last_clipboard_text);
 316
 317   /* Calls Int 2Fh/AX=1703h with:
 318                      DX = WinOldAp-Supported Clipboard format
 319                      ES:BX = Pointer to data
 320                      SI:CX = Size of data in bytes
 321      Return Values   AX == 0: Error occurred
 322                         <> 0: OK.  Data copied into the Clipboard.  */
 323   regs.x.ax = 0x1703;
 324   regs.x.dx = Format;
 325   regs.x.si = truelen >> 16;
 326   regs.x.cx = truelen & 0xffff;
 327   regs.x.es = xbuf_addr >> 4;
 328   regs.x.bx = xbuf_addr & 15;
 329   __dpmi_int(0x2f, &regs);
 330
 331   free_xfer_buf ();
 332
 333   /* If the above failed, invalidate the local copy of the clipboard.  */
 334   if (regs.x.ax == 0)
 335     *last_clipboard_text = '\0';
 336
 337   /* Zero means success, otherwise (1, 2, or 3) it's an error.  */
 338   return regs.x.ax > 0 ? 0 : 3;
 339 }
 340
 341 /* Return the size of the clipboard data of format FORMAT.  */
 342 unsigned
 343 get_clipboard_data_size (Format)
 344      unsigned Format;
 345 {
 346   __dpmi_regs regs;
 347
 348   /* Calls Int 2Fh/AX=1704h with:
 349                      DX = WinOldAp-Supported Clipboard format
 350      Return Values   DX:AX == Size of the data in bytes, including any
 351                               headers.
 352                            == 0 If data in this format is not in
 353                            the clipboard.  */
 354   regs.x.ax = 0x1704;
 355   regs.x.dx = Format;
 356   __dpmi_int(0x2f, &regs);
 357   return ( (((unsigned)regs.x.dx) << 16) | regs.x.ax);
 358 }
 359
 360 /* Get clipboard data, return its length.
 361    Warning: this doesn't check whether DATA has enough space to hold
 362    SIZE bytes.  */
 363 unsigned
 364 get_clipboard_data (Format, Data, Size, Raw)
 365      unsigned Format;
 366      void *Data;
 367      unsigned Size;
 368      int Raw;
 369 {
 370   __dpmi_regs regs;
 371   unsigned long xbuf_addr;
 372   unsigned char *dp = Data;
 373
 374   if (Format != CF_OEMTEXT)
 375     return 0;
 376
 377   if (Size == 0)
 378     return 0;
 379
 380   if ((xbuf_addr = alloc_xfer_buf (Size)) == 0)
 381     return 0;
 382
 383   /* Calls Int 2Fh/AX=1705h with:
 384                      DX = WinOldAp-Supported Clipboard format
 385                      ES:BX = Pointer to data buffer to hold data
 386      Return Values   AX == 0: Error occurred (or data in this format is not
 387                               in the clipboard)
 388                         <> 0: OK  */
 389   regs.x.ax = 0x1705;
 390   regs.x.dx = Format;
 391   regs.x.es = xbuf_addr >> 4;
 392   regs.x.bx = xbuf_addr & 15;
 393   __dpmi_int(0x2f, &regs);
 394   if (regs.x.ax != 0)
 395     {
 396       unsigned char null_char = '\0';
 397       unsigned long xbuf_beg = xbuf_addr;
 398
 399       /* If last_clipboard_text is NULL, we don't want to slow down
 400          the next loop by an additional test.  */
 401       register unsigned char *lcdp =
 402         last_clipboard_text == NULL ? &null_char : last_clipboard_text;
 403
 404       /* Copy data from low memory, remove CR
 405          characters before LF if needed.  */
 406       _farsetsel (_dos_ds);
 407       while (Size--)
 408         {
 409           register unsigned char c = _farnspeekb (xbuf_addr++);
 410
 411           if (*lcdp == c)
 412             lcdp++;
 413
 414           if ((*dp++ = c) == '\r' && !Raw && _farnspeekb (xbuf_addr) == '\n')
 415             {
 416               dp--;
 417               *dp++ = '\n';
 418               xbuf_addr++;
 419               if (*lcdp == '\n')
 420                 lcdp++;
 421             }
 422           /* Windows reportedly rounds up the size of clipboard data
 423              (passed in SIZE) to a multiple of 32, and removes trailing
 424              spaces from each line without updating SIZE.  We therefore
 425              bail out when we see the first null character.  */
 426           else if (c == '\0')
 427             break;
 428         }
 429
 430       /* If the text in clipboard is identical to what we put there
 431          last time set_clipboard_data was called, pretend there's no
 432          data in the clipboard.  This is so we don't pass our own text
 433          from the clipboard (which might be troublesome if the killed
 434          text includes null characters).  */
 435       if (last_clipboard_text &&
 436           xbuf_addr - xbuf_beg == (long)(lcdp - last_clipboard_text))
 437         dp = (unsigned char *)Data + 1;
 438     }
 439
 440   free_xfer_buf ();
 441
 442   return (unsigned) (dp - (unsigned char *)Data - 1);
 443 }
 444
 445 /* Close clipboard, return non-zero if successfull.  */
 446 unsigned
 447 close_clipboard ()
 448 {
 449   __dpmi_regs regs;
 450
 451   /* Calls Int 2Fh/AX=1708h
 452      Return Values   AX == 0: Error occurred
 453                         <> 0: OK */
 454   regs.x.ax = 0x1708;
 455   __dpmi_int(0x2f, &regs);
 456   return regs.x.ax;
 457 }
 458
 459 /* Compact clipboard data so that at least SIZE bytes is available.  */
 460 unsigned
 461 clipboard_compact (Size)
 462      unsigned Size;
 463 {
 464   __dpmi_regs regs;
 465
 466   /* Calls Int 2Fh/AX=1709H with:
 467                      SI:CX = Desired memory size in bytes.
 468      Return Values   DX:AX == Number of bytes of largest block of free memory.
 469                            == 0 if error or no memory  */
 470   regs.x.ax = 0x1709;
 471   regs.x.si = Size >> 16;
 472   regs.x.cx = Size & 0xffff;
 473   __dpmi_int(0x2f, &regs);
 474   return ((unsigned)regs.x.dx << 16) | regs.x.ax;
 475 }
 476 \f
 477 static char no_mem_msg[] =
 478   "(Not enough DOS memory to put saved text into clipboard.)";
 479 static char binary_msg[] =
 480   "(Binary characters in saved text; clipboard data not set.)";
 481 static char system_error_msg[] =
 482   "(Clipboard interface failure; clipboard data not set.)";
 483
 484 DEFUN ("w16-set-clipboard-data", Fw16_set_clipboard_data, Sw16_set_clipboard_data, 1, 2, 0,
 485        doc: /* This sets the clipboard data to the given text.  */)
 486      (string, frame)
 487      Lisp_Object string, frame;
 488 {
 489   unsigned ok = 1, put_status = 0;
 490   int nbytes, charset_info, no_crlf_conversion;
 491   unsigned char *src, *dst = NULL;
 492
 493   CHECK_STRING (string);
 494
 495   if (NILP (frame))
 496     frame = Fselected_frame ();
 497
 498   CHECK_LIVE_FRAME (frame);
 499   if ( !FRAME_MSDOS_P (XFRAME (frame)))
 500     goto done;
 501
 502   BLOCK_INPUT;
 503
 504   nbytes = SBYTES (string);
 505   src = SDATA (string);
 506
 507   /* Since we are now handling multilingual text, we must consider
 508      encoding text for the clipboard.  */
 509   charset_info = find_charset_in_text (src, SCHARS (string), nbytes,
 510                                        NULL, Qnil);
 511
 512   if (charset_info == 0)
 513     {
 514       /* No multibyte character in OBJ.  We need not encode it, but we
 515          will have to convert it to DOS CR-LF style.  */
 516       no_crlf_conversion = 0;
 517     }
 518   else
 519     {
 520       /* We must encode contents of STRING according to what
 521          clipboard-coding-system specifies.  */
 522       int bufsize;
 523       struct coding_system coding;
 524       unsigned char *htext2;
 525
 526       if (NILP (Vnext_selection_coding_system))
 527         Vnext_selection_coding_system = Vselection_coding_system;
 528       setup_coding_system
 529         (Fcheck_coding_system (Vnext_selection_coding_system), &coding);
 530       if (SYMBOLP (coding.pre_write_conversion)
 531           && !NILP (Ffboundp (coding.pre_write_conversion)))
 532         {
 533           string = run_pre_post_conversion_on_str (string, &coding, 1);
 534           src = SDATA (string);
 535           nbytes = SBYTES (string);
 536         }
 537       coding.src_multibyte = 1;
 538       coding.dst_multibyte = 0;
 539       Vnext_selection_coding_system = Qnil;
 540       coding.mode |= CODING_MODE_LAST_BLOCK;
 541       Vlast_coding_system_used = coding.symbol;
 542       bufsize = encoding_buffer_size (&coding, nbytes);
 543       dst = (unsigned char *) xmalloc (bufsize);
 544       encode_coding (&coding, src, dst, nbytes, bufsize);
 545       no_crlf_conversion = 1;
 546       nbytes = coding.produced;
 547       src = dst;
 548     }
 549
 550   if (!open_clipboard ())
 551     goto error;
 552
 553   ok = empty_clipboard ()
 554     && ((put_status
 555          = set_clipboard_data (CF_OEMTEXT, src, nbytes, no_crlf_conversion))
 556         == 0);
 557
 558   if (!no_crlf_conversion)
 559     Vlast_coding_system_used = Qraw_text;
 560   close_clipboard ();
 561
 562   if (ok) goto unblock;
 563
 564  error:
 565
 566   ok = 0;
 567
 568  unblock:
 569   if (dst)
 570     xfree (dst);
 571   UNBLOCK_INPUT;
 572
 573   /* Notify user if the text is too large to fit into DOS memory.
 574      (This will happen somewhere after 600K bytes (470K in DJGPP v1.x),
 575      depending on user system configuration.)  If we just silently
 576      fail the function, people might wonder why their text sometimes
 577      doesn't make it to the clipboard.  */
 578   if (put_status)
 579     {
 580       switch (put_status)
 581         {
 582           case 1:
 583             message2 (no_mem_msg, sizeof (no_mem_msg) - 1, 0);
 584             break;
 585           case 2:
 586             message2 (binary_msg, sizeof (binary_msg) - 1, 0);
 587             break;
 588           case 3:
 589             message2 (system_error_msg, sizeof (system_error_msg) - 1, 0);
 590             break;
 591         }
 592       sit_for (2, 0, 0, 1, 1);
 593     }
 594
 595  done:
 596
 597   return (ok && put_status == 0 ? string : Qnil);
 598 }
 599
 600 DEFUN ("w16-get-clipboard-data", Fw16_get_clipboard_data, Sw16_get_clipboard_data, 0, 1, 0,
 601        doc: /* This gets the clipboard data in text format.  */)
 602      (frame)
 603      Lisp_Object frame;
 604 {
 605   unsigned data_size, truelen;
 606   unsigned char *htext;
 607   Lisp_Object ret = Qnil;
 608   int no_crlf_conversion, require_encoding = 0;
 609
 610   if (NILP (frame))
 611     frame = Fselected_frame ();
 612
 613   CHECK_LIVE_FRAME (frame);
 614   if ( !FRAME_MSDOS_P (XFRAME (frame)))
 615     goto done;
 616
 617   BLOCK_INPUT;
 618
 619   if (!open_clipboard ())
 620     goto unblock;
 621
 622   if ((data_size = get_clipboard_data_size (CF_OEMTEXT)) == 0 ||
 623       (htext = (unsigned char *)xmalloc (data_size)) == 0)
 624     goto closeclip;
 625
 626   /* need to know final size after '\r' chars are removed because
 627      we can't change the string size manually, and doing an extra
 628      copy is silly */
 629   if ((truelen = get_clipboard_data (CF_OEMTEXT, htext, data_size, 0)) == 0)
 630     goto closeclip;
 631
 632   /* Do we need to decode it?  */
 633   {
 634     /* If the clipboard data contains any 8-bit Latin-1 code, we
 635        need to decode it.  */
 636     int i;
 637
 638     for (i = 0; i < truelen; i++)
 639       {
 640         if (htext[i] >= 0x80)
 641           {
 642             require_encoding = 1;
 643             break;
 644           }
 645       }
 646   }
 647   if (require_encoding)
 648     {
 649       int bufsize;
 650       unsigned char *buf;
 651       struct coding_system coding;
 652
 653       if (NILP (Vnext_selection_coding_system))
 654         Vnext_selection_coding_system = Vselection_coding_system;
 655       setup_coding_system
 656         (Fcheck_coding_system (Vnext_selection_coding_system), &coding);
 657       coding.src_multibyte = 0;
 658       coding.dst_multibyte = 1;
 659       Vnext_selection_coding_system = Qnil;
 660       coding.mode |= CODING_MODE_LAST_BLOCK;
 661       /* We explicitely disable composition handling because selection
 662          data should not contain any composition sequence.  */
 663       coding.composing = COMPOSITION_DISABLED;
 664       truelen = get_clipboard_data (CF_OEMTEXT, htext, data_size, 1);
 665       bufsize = decoding_buffer_size (&coding, truelen);
 666       buf = (unsigned char *) xmalloc (bufsize);
 667       decode_coding (&coding, htext, buf, truelen, bufsize);
 668       ret = make_string_from_bytes ((char *) buf,
 669                                     coding.produced_char, coding.produced);
 670       xfree (buf);
 671       if (SYMBOLP (coding.post_read_conversion)
 672           && !NILP (Ffboundp (coding.post_read_conversion)))
 673         ret = run_pre_post_conversion_on_str (ret, &coding, 0);
 674       Vlast_coding_system_used = coding.symbol;
 675     }
 676   else
 677     {
 678       ret = make_unibyte_string ((char *) htext, truelen);
 679       Vlast_coding_system_used = Qraw_text;
 680     }
 681
 682   xfree (htext);
 683
 684  closeclip:
 685   close_clipboard ();
 686
 687  unblock:
 688   UNBLOCK_INPUT;
 689
 690  done:
 691
 692   return (ret);
 693 }
 694
 695 /* Support checking for a clipboard selection. */
 696
 697 DEFUN ("x-selection-exists-p", Fx_selection_exists_p, Sx_selection_exists_p,
 698        0, 1, 0,
 699        doc: /* Whether there is an owner for the given X Selection.
 700 The arg should be the name of the selection in question, typically one of
 701 the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.
 702 \(Those are literal upper-case symbol names, since that's what X expects.)
 703 For convenience, the symbol nil is the same as `PRIMARY',
 704 and t is the same as `SECONDARY'.  */)
 705      (selection)
 706      Lisp_Object selection;
 707 {
 708   CHECK_SYMBOL (selection);
 709
 710   /* Return nil for SECONDARY selection.  For PRIMARY (or nil)
 711      selection, check if there is some text on the kill-ring;
 712      for CLIPBOARD, check if the clipboard currently has valid
 713      text format contents.
 714
 715      The test for killed text on the kill-ring emulates the Emacs
 716      behavior on X, where killed text is also put into X selection
 717      by the X interface code.  (On MSDOS, killed text is only put
 718      into the clipboard if we run under Windows, so we cannot check
 719      the clipboard alone.)  */
 720   if ((EQ (selection, Qnil) || EQ (selection, QPRIMARY))
 721       && ! NILP (SYMBOL_VALUE (Fintern_soft (build_string ("kill-ring"),
 722                                              Qnil))))
 723     return Qt;
 724
 725   if (EQ (selection, QCLIPBOARD))
 726     {
 727       Lisp_Object val = Qnil;
 728
 729       if (open_clipboard ())
 730         {
 731           if (get_clipboard_data_size (CF_OEMTEXT))
 732             val = Qt;
 733           close_clipboard ();
 734         }
 735       return val;
 736     }
 737   return Qnil;
 738 }
 739
 740 void
 741 syms_of_win16select ()
 742 {
 743   defsubr (&Sw16_set_clipboard_data);
 744   defsubr (&Sw16_get_clipboard_data);
 745   defsubr (&Sx_selection_exists_p);
 746
 747   DEFVAR_LISP ("selection-coding-system", &Vselection_coding_system,
 748                doc: /* Coding system for communicating with other X clients.
 749 When sending or receiving text via cut_buffer, selection, and clipboard,
 750 the text is encoded or decoded by this coding system.
 751 The default value is `iso-latin-1-dos'.  */);
 752   Vselection_coding_system = intern ("iso-latin-1-dos");
 753
 754   DEFVAR_LISP ("next-selection-coding-system", &Vnext_selection_coding_system,
 755                doc: /* Coding system for the next communication with other X clients.
 756 Usually, `selection-coding-system' is used for communicating with
 757 other X clients.  But, if this variable is set, it is used for the
 758 next communication only.  After the communication, this variable is
 759 set to nil.  */);
 760   Vnext_selection_coding_system = Qnil;
 761
 762   QPRIMARY   = intern ("PRIMARY");      staticpro (&QPRIMARY);
 763   QCLIPBOARD = intern ("CLIPBOARD");    staticpro (&QCLIPBOARD);
 764 }
 765
 766 #endif /* MSDOS */