File: dde.pl

package info (click to toggle)
swi-prolog 8.0.2+dfsg-3+deb10u1
  • links: PTS, VCS
  • area: main
  • in suites: buster
  • size: 72,036 kB
  • sloc: ansic: 349,612; perl: 306,654; java: 5,208; cpp: 4,436; sh: 3,042; ruby: 1,594; yacc: 845; makefile: 136; xml: 82; sed: 12; sql: 6
file content (245 lines) | stat: -rw-r--r-- 8,716 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
/*  Part of SWI-Prolog

    Author:        Jan Wielemaker
    E-mail:        J.Wielemaker@vu.nl
    WWW:           http://www.swi-prolog.org
    Copyright (c)  1995-2013, University of Amsterdam
                              VU University Amsterdam
    All rights reserved.

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:

    1. Redistributions of source code must retain the above copyright
       notice, this list of conditions and the following disclaimer.

    2. Redistributions in binary form must reproduce the above copyright
       notice, this list of conditions and the following disclaimer in
       the documentation and/or other materials provided with the
       distribution.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    POSSIBILITY OF SUCH DAMAGE.
*/

:- module(win_dde,
          [ dde_request/3,              % +Handle, +Key, -Value
            dde_execute/2,              % +Handle, +Command
            dde_poke/3,                 % +Handle, +Item, +Data
            dde_register_service/2,     % +Template, +Goal
            dde_unregister_service/1,   % +Service
            dde_current_service/2,      % -Service, -Topic
            dde_current_connection/2    % -Service, -Topic
          ]).

:- meta_predicate
    dde_register_service(+, 0).

/** <module> Windows DDE interface

This module provides both a client and   server interface to Windows DDE
(Dynamic Data Exchange) facilities. DDE provides a proprietary means for
interprocess communication based on Windows  messages. This implies that
applications that wish to use these   predicates  must provide a Windows
`message loop'. Typically, this  is  provided   by  the  GUI frontend of
SWI-Prolog. If SWI-Prolog is embedded,   the  embedding environment must
provide the message loop.

Errors from the DDE layer are mapped to error-terms of this format

  ==
  error(dde_error(Operation, Message), Context)
  ==

The interaction between DDE and threads is   unclear  to us. The current
implementation uses a DDE instance for each   thread that executes a DDE
predicate. Although not protected, we advice  to use a particular handle
only from the thread in which it  was created and to unregister services
from the thread that created them.

@see    library(socket) provides platform independent interprocess
        communication.
*/

                 /*******************************
                 *            CLIENT            *
                 *******************************/

%!  dde_request(+Handle, +Key, -Value) is det.
%
%   Make a DDE request  with  default   timeout  value  (meaning the
%   request  can  block  forever).   Value    is   unified   with  a
%   string-object (see string_list/2) on success.

dde_request(Handle, Key, Value) :-
    dde_request(Handle, Key, Value, 0).

%!  dde_execute(+Handle, +Command) is det.
%
%   Make a DDE execute request with default timeout value.

dde_execute(Handle, Command) :-
    dde_execute(Handle, Command, 0).

%!  dde_poke(+Handle, +Item, +Data) is det.
%
%   Make a DDE poke request with default timeout value.

dde_poke(Handle, Item, Data) :-
    dde_poke(Handle, Item, Data, 0).


                 /*******************************
                 *            SERVER            *
                 *******************************/

:- dynamic
    dde_service/6,
    dde_current_connection/3.

%!  dde_register_service(Template, +Goal) is det.
%
%   Register a DDE service  in   this  SWI-Prolog instance. Template
%   takes one of the formats
%
%           $ Service(Topic, Item, Value) :
%           Register a service for dde_request/3
%
%           $ Service(Topic, Command) :
%           Register a service for dde_execute/2
%
%   Topic is either an atom or a variable.  In the latter case, any
%   topic is confirmed on the Service.  Item, Value and Command are
%   variables used to pass the arguments into the Goal.

dde_register_service(Template, Goal) :-
    Template =.. [Service, Topic, Item, Value],
    !,
    strip_module(Goal, Module, PlainGoal),
    '$dde_register_service'(Service, on),
    asserta(win_dde:dde_service(Service, Topic, Item,
                                Value, Module, PlainGoal)).
dde_register_service(Template, Goal) :-
    Template =.. [Service, Topic, Command],
    !,
    strip_module(Goal, Module, PlainGoal),
    '$dde_register_service'(Service, on),
    asserta(win_dde:dde_service(Service, Topic, -,
                                Command, Module, PlainGoal)).
dde_register_service(Template, _Goal) :-
    throw(error(type_error(dde_service, Template), _)).

%!  dde_unregister_service(+Service) is det.
%
%   Unregister a previously registered service. Succeeds silently if
%   the service was not registered.
%
%   @see dde_current_service/2.

dde_unregister_service(Service) :-
    (   retract(dde_service(Service, _, _, _, _, _))
    ->  '$dde_register_service'(Service, off)
    ;   true
    ),
    retractall(dde_service(Service, _, _, _, _, _)).

dde_unregister_all_services :-
    dde_current_service(Service, _),
    dde_unregister_service(Service),
    fail ; true.

:- at_halt(dde_unregister_all_services). % required by Windows!

%!  dde_current_service(?Service, ?Topic)
%
%   Unifies Service and Topic with currently supported servers/topics

dde_current_service(Service, Topic) :-
    dde_service(Service, Topic, _, _, _, _).

%!  dde_current_connection(?Service, ?Topic)
%
%   Unifies Service and Topic with the currently open server connections.

dde_current_connection(Service, Topic) :-
    dde_current_connection(_, Service, Topic).

                 /*******************************
                 *          CALL-BACKS          *
                 *******************************/

%       '$dde_connect'(+Service, +Topic, +IsSelf)
%
%       Called by the DDEML XTYP_CONNECT request.  IsSelf is 0 if the
%       connection is requested by another Prolog, 1 otherwise.

'$dde_connect'(Service, Topic, _Self) :-
    dde_service(Service, Topic, _, _, _, _).

%       '$dde_connect_confirm'(+Service, +Topic, +Handle)
%
%       Called by the DDEML XTYP_CONNECT_CONFIRM request.  Used to update
%       our list of current conversations.

'$dde_connect_confirm'(Service, Topic, Handle) :-
    asserta(dde_current_connection(Handle, Service, Topic)).

%       '$dde_disconnect'(+Handle)
%
%       Called by the DDEML XTYP_DISCONNECT request.  Used to update our
%       list of current conversations.

'$dde_disconnect'(Handle) :-
    retractall(dde_current_connection(Handle, _, _)).

%       '$dde_request'(+Handle, +Topic, +Item, -Answer)
%
%       Called by the DDEML XTYP_REQUEST request.  Answer should be unified
%       with a Prolog object that can be translated into a textual value
%       (atom, string, number or list-of-ascii-values).

'$dde_request'(Handle, Topic, Item, Answer) :-
    dde_current_connection(Handle, Service, Topic),
    dde_service(Service, Topic, Item, Value, Module, Goal),
    !,
    Module:Goal,
    Answer = Value.
'$dde_request'(_Handle, Topic, _Item, _Answer) :-
    throw(error(existence_error(dde_topic, Topic), _)).

%       '$dde_execute'(+Handle, +Topic, +Command)
%
%       Called  by  the  DDEML  XTYP_EXECUTE    request.  Command  is  a
%       SWI-Prolog string object. Use  atom_string   or  string_codes to
%       convert it into a standard object.

'$dde_execute'(Handle, Topic, Command) :-
    dde_current_connection(Handle, Service, Topic),
    dde_service(Service, Topic, _, Command, Module, Goal),
    !,
    Module:Goal.
'$dde_execute'(_Handle, Topic, _Command) :-
    throw(error(existence_error(dde_topic, Topic), _)).


                 /*******************************
                 *             ERRORS           *
                 *******************************/

:- multifile
    prolog:error_message//1.


prolog:error_message(dde_error(Op,Msg)) -->
    [ 'DDE: ~w failed: ~w'-[Op,Msg] ].