1 /*************************************************************************
2 * *
3 * YAP Prolog *
4 * *
5 * Yap Prolog was developed at NCCUP - Universidade do Porto *
6 * *
7 * Copyright S. Konstantopoulos and Universidade do Porto 2002 *
8 * *
9 **************************************************************************
10 * *
11 * File: mpe.c *
12 * Last rev: $Date: 2003-07-03 15:46:10 $ *
13 * mods: *
14 * comments: Interface to an MPE library *
15 * *
16 *************************************************************************/
17
18 #ifndef lint
19 static char *rcsid = "$Header: /Users/vitor/Yap/yap-cvsbackup/library/mpi/mpe.c,v 1.6 2003-07-03 15:46:10 stasinos Exp $";
20 #endif
21
22 #include "Yap.h"
23
24 #if HAVE_MPE
25
26 #if 0
27 /* for AtomEof */
28 #include "Heap.h"
29
30 #include "yapio.h"
31
32 #include <stdlib.h>
33 #include <string.h>
34 #endif
35
36 #include "Yatom.h"
37 #include <mpe.h>
38
39 STATIC_PROTO (Int p_init, (void));
40 STATIC_PROTO (Int p_start, (void));
41 STATIC_PROTO (Int p_close, (void));
42 STATIC_PROTO (Int p_create_event, (void));
43 STATIC_PROTO (Int p_create_state, (void));
44 STATIC_PROTO (Int p_log, (void));
45
46
47 /*
48 * Auxiliary Data and Functions
49 */
50
51
52
53 /*
54 * C Predicates
55 */
56
57
58 static Int
p_init()59 p_init() /* mpe_open */
60 {
61 return (MPE_Init_log() == 0);
62 }
63
64
65 static Int
p_start()66 p_start() /* mpe_start */
67 {
68 return (MPE_Start_log() == 0);
69 }
70
71
72 static Int /* mpe_close(+FileName) */
p_close()73 p_close()
74 {
75 Term t_str = Deref(ARG1);
76 char *str;
77
78 /* The arg must be bound to an atom. */
79 if (IsVarTerm(t_str)) {
80 Yap_Error(INSTANTIATION_ERROR, t_str, "mpe_close");
81 return (FALSE);
82 } else if( !IsAtomTerm(t_str) ) {
83 Yap_Error(TYPE_ERROR_ATOM, t_str, "mpe_close");
84 return (FALSE);
85 } else {
86 str = RepAtom(AtomOfTerm(t_str))->StrOfAE;
87 }
88
89 return (MPE_Finish_log(str) == 0);
90 }
91
92
93 static Int /* mpe_create_event(?Event) */
p_create_event()94 p_create_event()
95 {
96 Int event_id;
97
98 event_id = MPE_Log_get_event_number();
99 return Yap_unify(ARG1, MkIntegerTerm(event_id));
100 }
101
102 static Int /* mpe_create_state(+Event,+Event,+Text,+Colour) */
p_create_state()103 p_create_state()
104 {
105 Term t_start = Deref(ARG1), t_end = Deref(ARG2),
106 t_descr = Deref(ARG3), t_colour = Deref(ARG4);
107 Int start_id, end_id;
108 char *descr, *colour;
109 int retv;
110
111 /* The first and second args must be bount to integer event IDs. */
112 if (IsVarTerm(t_start)) {
113 Yap_Error(INSTANTIATION_ERROR, t_start, "mpe_create_state");
114 return (FALSE);
115 } else if( !IsIntegerTerm(t_start) ) {
116 Yap_Error(TYPE_ERROR_INTEGER, t_start, "mpe_create_state");
117 return (FALSE);
118 } else {
119 start_id = IntOfTerm(t_start);
120 }
121 if (IsVarTerm(t_end)) {
122 Yap_Error(INSTANTIATION_ERROR, t_end, "mpe_create_state");
123 return (FALSE);
124 } else if( !IsIntegerTerm(t_end) ) {
125 Yap_Error(TYPE_ERROR_INTEGER, t_end, "mpe_create_state");
126 return (FALSE);
127 } else {
128 end_id = IntOfTerm(t_end);
129 }
130
131 /* The third and fourth args must be bound to atoms. */
132 if (IsVarTerm(t_descr)) {
133 Yap_Error(INSTANTIATION_ERROR, t_descr, "mpe_create_state");
134 return (FALSE);
135 } else if( !IsAtomTerm(t_descr) ) {
136 Yap_Error(TYPE_ERROR_ATOM, t_descr, "mpe_create_state");
137 return (FALSE);
138 } else {
139 descr = RepAtom(AtomOfTerm(t_descr))->StrOfAE;
140 }
141 if (IsVarTerm(t_colour)) {
142 Yap_Error(INSTANTIATION_ERROR, t_colour, "mpe_create_state");
143 return (FALSE);
144 } else if( !IsAtomTerm(t_colour) ) {
145 Yap_Error(TYPE_ERROR_ATOM, t_colour, "mpe_create_state");
146 return (FALSE);
147 } else {
148 colour = RepAtom(AtomOfTerm(t_colour))->StrOfAE;
149 }
150
151 retv = MPE_Describe_state( (int)start_id, (int)end_id, descr, colour );
152
153 return (retv == 0);
154 }
155
156
157 static Int
p_log()158 p_log() /* mpe_log(+EventType, +EventNum, +EventStr) */
159 {
160 Term t_type = Deref(ARG1), t_num = Deref(ARG2), t_str = Deref(ARG3);
161 Int event_id, event;
162 char *descr;
163
164 /* The first arg must be bount to integer event type ID. */
165 if (IsVarTerm(t_type)) {
166 Yap_Error(INSTANTIATION_ERROR, t_type, "mpe_log");
167 return (FALSE);
168 } else if( !IsIntegerTerm(t_type) ) {
169 Yap_Error(TYPE_ERROR_INTEGER, t_type, "mpe_log");
170 return (FALSE);
171 } else {
172 event_id = IntOfTerm(t_type);
173 }
174
175 /* The second arg must be bount to integer event number. */
176 if (IsVarTerm(t_num)) {
177 Yap_Error(INSTANTIATION_ERROR, t_num, "mpe_log");
178 return (FALSE);
179 } else if( !IsIntegerTerm(t_num) ) {
180 Yap_Error(TYPE_ERROR_INTEGER, t_num, "mpe_log");
181 return (FALSE);
182 } else {
183 event = IntOfTerm(t_num);
184 }
185
186 /* The third arg must be bound to an atom. */
187 if (IsVarTerm(t_str)) {
188 Yap_Error(INSTANTIATION_ERROR, t_str, "mpe_log");
189 return (FALSE);
190 } else if( !IsAtomTerm(t_str) ) {
191 Yap_Error(TYPE_ERROR_ATOM, t_str, "mpe_log");
192 return (FALSE);
193 } else {
194 descr = RepAtom(AtomOfTerm(t_str))->StrOfAE;
195 }
196
197 return ( MPE_Log_event((int)event_id, (int)event, descr) == 0 );
198 }
199
200
201 /*
202 * Init
203 */
204
205
206 void
Yap_InitMPE(void)207 Yap_InitMPE(void)
208 {
209 Yap_InitCPred( "mpe_open", 0, p_init, SafePredFlag );
210 Yap_InitCPred( "mpe_start", 0, p_start, SafePredFlag );
211 Yap_InitCPred( "mpe_close", 1, p_close, SafePredFlag );
212 Yap_InitCPred( "mpe_create_event", 1, p_create_event, SafePredFlag );
213 Yap_InitCPred( "mpe_create_state", 4, p_create_state, SafePredFlag );
214 Yap_InitCPred( "mpe_log", 3, p_log, SafePredFlag );
215 }
216
217 #endif /* HAVE_MPE */
218