static HGLOBAL
convert_to_handle_as_coded (Lisp_Object coding_system)
{
HGLOBAL htext;
unsigned char *dst = NULL;
struct coding_system coding;
ONTRACE (fprintf (stderr, "convert_to_handle_as_coded: %s\n",
SDATA (SYMBOL_NAME (coding_system))));
setup_windows_coding_system (coding_system, &coding);
coding.dst_bytes = SBYTES (current_text) * 2;
coding.destination = xmalloc (coding.dst_bytes);
encode_coding_object (&coding, current_text, 0, 0,
SCHARS (current_text), SBYTES (current_text), Qnil);
htext = GlobalAlloc (GMEM_MOVEABLE | GMEM_DDESHARE, coding.produced +2);
if (htext != NULL)
dst = (unsigned char *) GlobalLock (htext);
if (dst != NULL)
{
memcpy (dst, coding.destination, coding.produced);
/* Add the string terminator. Add two NULs in case we are
producing Unicode here. */
dst[coding.produced] = dst[coding.produced+1] = '\0';
GlobalUnlock (htext);
}
xfree (coding.destination);
return htext;
}
static Lisp_Object
render_locale (void)
{
HANDLE hlocale = NULL;
LCID * lcid_ptr;
ONTRACE (fprintf (stderr, "render_locale\n"));
if (current_lcid == LOCALE_NEUTRAL || current_lcid == DEFAULT_LCID)
return Qt;
hlocale = GlobalAlloc (GMEM_MOVEABLE | GMEM_DDESHARE, sizeof (current_lcid));
if (hlocale == NULL)
return Qnil;
if ((lcid_ptr = (LCID *) GlobalLock (hlocale)) == NULL)
{
GlobalFree (hlocale);
return Qnil;
}
*lcid_ptr = current_lcid;
GlobalUnlock (hlocale);
if (SetClipboardData (CF_LOCALE, hlocale) == NULL)
{
GlobalFree (hlocale);
return Qnil;
}
return Qt;
}
TCA UniqueStubs::add(const char* name, TCA start) {
auto const inAStubs = start > mcg->code.stubs().base();
UNUSED auto const stop = inAStubs ? mcg->code.stubs().frontier()
: mcg->code.main().frontier();
FTRACE(1, "unique stub: {} {} -- {:4} bytes: {}\n",
inAStubs ? "astubs @ "
: " ahot @ ",
static_cast<void*>(start),
static_cast<size_t>(stop - start),
name);
ONTRACE(2,
[&]{
Disasm dasm(Disasm::Options().indent(4));
std::ostringstream os;
dasm.disasm(os, start, stop);
FTRACE(2, "{}\n", os.str());
}()
);
mcg->recordGdbStub(
mcg->code.blockFor(start),
start,
strdup(folly::format("HHVM::{}", name).str().c_str())
);
return start;
}
static Lisp_Object
render (Lisp_Object oformat)
{
HGLOBAL htext = NULL;
UINT format = XFASTINT (oformat);
ONTRACE (fprintf (stderr, "render\n"));
if (NILP (current_text))
return Qnil;
if (current_requires_encoding || format == CF_UNICODETEXT)
{
if (format == current_clipboard_type)
htext = convert_to_handle_as_coded (current_coding_system);
else
switch (format)
{
case CF_UNICODETEXT:
htext = convert_to_handle_as_coded (QUNICODE);
break;
case CF_TEXT:
case CF_OEMTEXT:
{
Lisp_Object cs;
cs = coding_from_cp (cp_from_locale (current_lcid, format));
htext = convert_to_handle_as_coded (cs);
break;
}
}
}
else
htext = convert_to_handle_as_ascii ();
ONTRACE (fprintf (stderr, "render: htext = 0x%08X\n", (unsigned) htext));
if (htext == NULL)
return Qnil;
if (SetClipboardData (format, htext) == NULL)
{
GlobalFree (htext);
return Qnil;
}
return Qt;
}
static Lisp_Object
render_all (Lisp_Object ignore)
{
ONTRACE (fprintf (stderr, "render_all\n"));
/* According to the docs we should not call OpenClipboard() here,
but testing on W2K and working code in other projects shows that
it is actually necessary. */
OpenClipboard (NULL);
/* There is no useful means to report errors here, there are none
expected anyway, and even if there were errors, they wouldn't do
any harm. So we just go ahead and do what has to be done without
bothering with error handling. */
++modifying_clipboard;
EmptyClipboard ();
--modifying_clipboard;
/* For text formats that we don't render here, the OS can use its
own translation rules instead, so we don't really need to offer
everything. To minimize memory consumption we cover three
possible situations based on our primary format as detected from
selection-coding-system (see setup_config()):
- Post CF_TEXT only. Let the OS convert to CF_OEMTEXT and the OS
(on NT) or the application (on 9x/Me) convert to
CF_UNICODETEXT.
- Post CF_OEMTEXT only. Similar automatic conversions happen as
for CF_TEXT.
- Post CF_UNICODETEXT + CF_TEXT. 9x itself ignores
CF_UNICODETEXT, even though some applications can still handle
it.
Note 1: We render the less capable CF_TEXT *before* the more
capable CF_UNICODETEXT, to prevent clobbering through automatic
conversions, just in case.
Note 2: We could check os_subtype here and only render the
additional CF_TEXT on 9x/Me. But OTOH with
current_clipboard_type == CF_UNICODETEXT we don't involve the
automatic conversions anywhere else, so to get consistent
results, we probably don't want to rely on it here either. */
render_locale ();
if (current_clipboard_type == CF_UNICODETEXT)
render (make_number (CF_TEXT));
render (make_number (current_clipboard_type));
CloseClipboard ();
return Qnil;
}
static HGLOBAL
convert_to_handle_as_ascii (void)
{
HGLOBAL htext = NULL;
int nbytes;
int truelen;
unsigned char *src;
unsigned char *dst;
ONTRACE (fprintf (stderr, "convert_to_handle_as_ascii\n"));
nbytes = SBYTES (current_text) + 1;
src = SDATA (current_text);
/* We need to add to the size the number of LF chars where we have
to insert CR chars (the standard CF_TEXT clipboard format uses
CRLF line endings, while Emacs uses just LF internally). */
truelen = nbytes + current_num_nls;
if ((htext = GlobalAlloc (GMEM_MOVEABLE | GMEM_DDESHARE, truelen)) == NULL)
return NULL;
if ((dst = (unsigned char *) GlobalLock (htext)) == NULL)
{
GlobalFree (htext);
return NULL;
}
/* convert to CRLF line endings expected by clipboard */
while (1)
{
unsigned char *next;
/* copy next line or remaining bytes including '\0' */
next = _memccpy (dst, src, '\n', nbytes);
if (next)
{
/* copied one line ending with '\n' */
int copied = next - dst;
nbytes -= copied;
src += copied;
/* insert '\r' before '\n' */
next[-1] = '\r';
next[0] = '\n';
dst = next + 1;
}
else
/* copied remaining partial line -> now finished */
break;
}
GlobalUnlock (htext);
return htext;
}
static LRESULT CALLBACK ALIGN_STACK
owner_callback (HWND win, UINT msg, WPARAM wp, LPARAM lp)
{
switch (msg)
{
case WM_RENDERFORMAT:
ONTRACE (fprintf (stderr, "WM_RENDERFORMAT\n"));
run_protected (render, make_number (wp));
return 0;
case WM_RENDERALLFORMATS:
ONTRACE (fprintf (stderr, "WM_RENDERALLFORMATS\n"));
run_protected (render_all, Qnil);
return 0;
case WM_DESTROYCLIPBOARD:
if (!modifying_clipboard)
{
ONTRACE (fprintf (stderr, "WM_DESTROYCLIPBOARD (other)\n"));
current_text = Qnil;
current_coding_system = Qnil;
}
else
{
ONTRACE (fprintf (stderr, "WM_DESTROYCLIPBOARD (self)\n"));
}
return 0;
case WM_DESTROY:
if (win == clipboard_owner)
clipboard_owner = NULL;
break;
}
return DefWindowProc (win, msg, wp, lp);
}
void recordType(TypeProfileKey key, DataType dt) {
if (!profiles) return;
if (!isProfileRequest()) return;
assert(dt != KindOfUninit);
// Normalize strings to KindOfString.
if (dt == KindOfStaticString) dt = KindOfString;
TRACE(1, "recordType lookup: %s -> %d\n", key.m_name->data(), dt);
ValueProfile *prof = keyToVP(key, KeyToVPMode::Write);
if (prof->m_totalSamples != kMaxCounter) {
prof->m_totalSamples++;
// NB: we can't quite assert that we have fewer than kMaxCounter samples,
// because other threads are updating this structure without locks.
int dtIndex = getDataTypeIndex(dt);
if (prof->m_samples[dtIndex] < kMaxCounter) {
prof->m_samples[dtIndex]++;
}
}
ONTRACE(2, prof->dump());
}
static HGLOBAL
convert_to_handle_as_coded (Lisp_Object coding_system)
{
HGLOBAL htext = NULL, htext2;
int nbytes;
unsigned char *src;
unsigned char *dst = NULL;
int bufsize;
struct coding_system coding;
Lisp_Object string = Qnil;
ONTRACE (fprintf (stderr, "convert_to_handle_as_coded: %s\n",
SDATA (SYMBOL_NAME (coding_system))));
setup_coding_system (Fcheck_coding_system (coding_system), &coding);
coding.src_multibyte = 1;
coding.dst_multibyte = 0;
/* Need to set COMPOSITION_DISABLED, otherwise Emacs crashes in
encode_coding_iso2022 trying to dereference a null pointer. */
coding.composing = COMPOSITION_DISABLED;
if (coding.type == coding_type_iso2022)
coding.flags |= CODING_FLAG_ISO_SAFE;
coding.mode |= CODING_MODE_LAST_BLOCK;
/* Force DOS line-ends. */
coding.eol_type = CODING_EOL_CRLF;
if (SYMBOLP (coding.pre_write_conversion)
&& !NILP (Ffboundp (coding.pre_write_conversion)))
string = run_pre_post_conversion_on_str (current_text, &coding, 1);
else
string = current_text;
nbytes = SBYTES (string);
src = SDATA (string);
bufsize = encoding_buffer_size (&coding, nbytes) +2;
htext = GlobalAlloc (GMEM_MOVEABLE | GMEM_DDESHARE, bufsize);
if (htext != NULL)
dst = (unsigned char *) GlobalLock (htext);
if (dst != NULL)
{
encode_coding (&coding, src, dst, nbytes, bufsize-2);
/* Add the string terminator. Add two NULs in case we are
producing Unicode here. */
dst[coding.produced] = dst[coding.produced+1] = '\0';
}
if (dst != NULL)
GlobalUnlock (htext);
if (htext != NULL)
{
/* Shrink data block to actual size. */
htext2 = GlobalReAlloc (htext, coding.produced+2,
GMEM_MOVEABLE | GMEM_DDESHARE);
if (htext2 != NULL) htext = htext2;
}
return htext;
}
