word
pl_dde_execute(term_t handle, term_t command, term_t timeout)
{ int hdl;
char *cmdstr;
HDDEDATA Hvalue, data;
DWORD result;
long tmo;
if ( !get_conv_handle(handle, &hdl) ||
!PL_get_chars_ex(command, &cmdstr, CVT_ALL) ||
!PL_get_long_ex(timeout, &tmo) )
fail;
if ( tmo <= 0 )
tmo = TIMEOUT_VERY_LONG;
if ( !(data = DdeCreateDataHandle(ddeInst, cmdstr, strlen(cmdstr)+1,
0, 0, CF_TEXT, 0)) )
return dde_warning("dde_execute/3");
Hvalue = DdeClientTransaction((LPBYTE) data, (DWORD) -1,
conv_handle[hdl], 0L, 0,
XTYP_EXECUTE, (DWORD) tmo, &result);
if ( Hvalue )
succeed;
return dde_warning("execute");
}
static int
unify_hdata(term_t t, HDDEDATA data)
{ char buf[FASTBUFSIZE];
int len;
if ( !(len=DdeGetData(data, buf, sizeof(buf)-1, 0)) )
return dde_warning("data handle");
DEBUG(0, Sdprintf("DdeGetData() returned %d bytes\n", len));
if ( len == sizeof(buf)-1 )
{ if ( (len=DdeGetData(data, NULL, 0, 0)) > 0 )
{ char *b2 = malloc(len+1);
int rval;
DdeGetData(data, b2, len, 0);
b2[len] = 0;
rval = PL_unify_atom_chars(t, b2);
free(b2);
return rval;
}
return dde_warning("data handle");
}
buf[len] = 0;
return PL_unify_atom_chars(t, buf);
}
static atom_t
hszToAtom(HSZ hsz)
{ char buf[FASTBUFSIZE];
int len;
if ( !(len=DdeQueryString(ddeInst, hsz, buf, sizeof(buf)-1, CP_WINANSI)) )
{ dde_warning("string handle");
return NULL_ATOM;
}
if ( len == sizeof(buf)-1 )
{ if ( (len=DdeQueryString(ddeInst, hsz, NULL, 0, CP_WINANSI)) > 0 )
{ char *b2 = malloc(len+1);
atom_t a;
DdeQueryString(ddeInst, hsz, b2, len+1, CP_WINANSI);
a = lookupAtom(b2, len);
free(b2);
return a;
}
dde_warning("string handle");
}
return lookupAtom(buf, len);
}
static int
unify_hsz(DWORD ddeInst, term_t term, HSZ hsz)
{ wchar_t buf[FASTBUFSIZE];
int len;
if ( !(len=DdeQueryStringW(ddeInst, hsz, buf,
sizeof(buf)/sizeof(wchar_t)-1, CP_WINUNICODE)) )
{ dde_warning("string handle");
return NULL_ATOM;
}
if ( len == sizeof(buf)/sizeof(wchar_t)-1 )
{ if ( (len=DdeQueryStringW(ddeInst, hsz, NULL, 0, CP_WINUNICODE)) > 0 )
{ wchar_t *b2;
int rc;
if ( !(b2 = malloc((len+1)*sizeof(wchar_t))) )
return PL_no_memory();
DdeQueryStringW(ddeInst, hsz, b2, len+1, CP_WINUNICODE);
rc = PL_unify_wchars(term, PL_ATOM, len, b2);
free(b2);
return rc;
}
dde_warning("string handle");
}
return PL_unify_wchars(term, PL_ATOM, len, buf);
}
static word
unify_hdata(term_t t, HDDEDATA data)
{ BYTE buf[FASTBUFSIZE];
DWORD len;
if ( !(len=DdeGetData(data, buf, sizeof(buf), 0)) )
return dde_warning("data handle");
DEBUG(1, Sdprintf("DdeGetData() returned %ld bytes\n", (long)len));
if ( len == sizeof(buf) )
{ if ( (len=DdeGetData(data, NULL, 0, 0)) > 0 )
{ LPBYTE b2;
int rval;
if ( !(b2 = malloc(len)) )
return PL_no_memory();
DdeGetData(data, b2, len, 0);
rval = PL_unify_wchars(t, PL_ATOM, len/sizeof(wchar_t)-1, (wchar_t*)b2);
free(b2);
return rval;
}
return dde_warning("data handle");
}
return PL_unify_wchars(t, PL_ATOM, len/sizeof(wchar_t)-1, (wchar_t*)buf);
}
word
pl_dde_poke(term_t handle, term_t item, term_t data, term_t timeout)
{ int hdl;
char *datastr;
HDDEDATA Hvalue;
HSZ Hitem;
long tmo;
if ( !get_conv_handle(handle, &hdl) ||
!get_hsz(item, &Hitem) )
fail;
if ( !PL_get_chars(data, &datastr, CVT_ALL) )
return PL_error(NULL, 0, NULL, ERR_TYPE, ATOM_text, data);
if ( !PL_get_long(timeout, &tmo) )
return PL_error(NULL, 0, NULL, ERR_TYPE, ATOM_integer, timeout);
if ( tmo <= 0 )
tmo = TIMEOUT_VERY_LONG;
Hvalue = DdeClientTransaction(datastr, strlen(datastr)+1,
conv_handle[hdl], Hitem, CF_TEXT,
XTYP_POKE, (DWORD)tmo, NULL);
if ( !Hvalue )
return dde_warning("poke");
succeed;
}
static int
dde_initialise()
{ if ( ddeInst == (DWORD)NULL )
{ if (DdeInitialize(&ddeInst, (PFNCALLBACK)DdeCallback,
APPCLASS_STANDARD|CBF_FAIL_ADVISES|CBF_FAIL_POKES|
CBF_SKIP_REGISTRATIONS|CBF_SKIP_UNREGISTRATIONS,
0L)
!= DMLERR_NO_ERROR)
{ ddeInst = (DWORD) -1;
return dde_warning("initialise");
}
MODULE_dde = lookupModule(PL_new_atom("win_dde"));
FUNCTOR_dde_connect3 =
lookupFunctorDef(PL_new_atom("$dde_connect"), 3);
FUNCTOR_dde_connect_confirm3 =
lookupFunctorDef(PL_new_atom("$dde_connect_confirm"), 3);
FUNCTOR_dde_disconnect1 =
lookupFunctorDef(PL_new_atom("$dde_disconnect"), 1);
FUNCTOR_dde_request4 =
lookupFunctorDef(PL_new_atom("$dde_request"), 4);
FUNCTOR_dde_execute3 =
lookupFunctorDef(PL_new_atom("$dde_execute"), 3);
FUNCTOR_error1 =
lookupFunctorDef(ATOM_error, 1);
}
succeed;
}
static DWORD
dde_initialise(void)
{ GET_LD
DWORD ddeInst;
dde_init_constants();
if ( !(ddeInst=LD->os.dde_instance) )
{ if ( DdeInitializeW(&ddeInst, (PFNCALLBACK)DdeCallback,
APPCLASS_STANDARD|CBF_FAIL_ADVISES|CBF_FAIL_POKES|
CBF_SKIP_REGISTRATIONS|CBF_SKIP_UNREGISTRATIONS,
0L) == DMLERR_NO_ERROR)
{ LD->os.dde_instance = ddeInst;
#ifdef O_PLMT
PL_thread_at_exit(dde_uninitialise, NULL, FALSE);
#endif
} else
{ dde_warning("initialise");
}
DEBUG(1, Sdprintf("Thread %d: created ddeInst %d\n",
PL_thread_self(), ddeInst));
}
return ddeInst;
}
word
pl_dde_register_service(term_t topic, term_t onoff)
{ HSZ t;
int a;
TRY(dde_initialise());
if ( !get_hsz(topic, &t) )
fail;
if ( !PL_get_bool(onoff, &a) )
return PL_error(NULL, 0, NULL, ERR_TYPE, ATOM_bool, onoff);
if ( !a )
{ int rval = (int)DdeNameService(ddeInst, t, 0L, DNS_UNREGISTER);
DdeFreeStringHandle(ddeInst, t);
return rval ? TRUE : FALSE;
} else
{ if ( DdeNameService(ddeInst, t, 0L, DNS_REGISTER|DNS_FILTERON) )
succeed; /* should we free too? */
DdeFreeStringHandle(ddeInst, t);
return dde_warning("register_request");
}
}
