1
2 package zeus.concepts;
3
4 import java.util.*;
5 import java.io.*;
6 import zeus.util.*;
7
8 public class PerformativeParser implements PerformativeParserConstants {
9
10 final public Performative Message() throws ParseException {
11 String type;
12 Performative msg;
13 jj_consume_token(LBRACKET);
14 type = MessageType();
15 msg = new Performative(type);
16 label_1:
17 while (true) {
18 MessageParameter(msg);
19 switch (jj_nt.kind) {
20 case SENDER:
21 case RECEIVER:
22 case CONTENT:
23 case REPLY_WITH:
24 case REPLY_BY:
25 case IN_REPLY_TO:
26 case REPLY_TO:
27 case ENVELOPE:
28 case LANGUAGE:
29 case ONTOLOGY:
30 case PROTOCOL:
31 case CONVERSATION_ID:
32 ;
33 break;
34 default:
35 break label_1;
36 }
37 }
38 jj_consume_token(RBRACKET);
39 {if (true) return msg;}
40 throw new Error("Missing return statement in function");
41 }
42
43 final public String MessageType() throws ParseException {
44 Token t = null;
45 switch (jj_nt.kind) {
46 case ACCEPT:
47 t = jj_consume_token(ACCEPT);
48 break;
49 case AGREE:
50 t = jj_consume_token(AGREE);
51 break;
52 case CANCEL:
53 t = jj_consume_token(CANCEL);
54 break;
55 case CFP:
56 t = jj_consume_token(CFP);
57 break;
58 case CONFIRM:
59 t = jj_consume_token(CONFIRM);
60 break;
61 case DISCONFRIM:
62 t = jj_consume_token(DISCONFRIM);
63 break;
64 case FAILURE:
65 t = jj_consume_token(FAILURE);
66 break;
67 case INFORM:
68 t = jj_consume_token(INFORM);
69 break;
70 case INFORM_IF:
71 t = jj_consume_token(INFORM_IF);
72 break;
73 case INFORM_REF:
74 t = jj_consume_token(INFORM_REF);
75 break;
76 case NOT_UNDERSTOOD:
77 t = jj_consume_token(NOT_UNDERSTOOD);
78 break;
79 case PROPOSE:
80 t = jj_consume_token(PROPOSE);
81 break;
82 case QUERY_IF:
83 t = jj_consume_token(QUERY_IF);
84 break;
85 case QUERY_REF:
86 t = jj_consume_token(QUERY_REF);
87 break;
88 case REFUSE:
89 t = jj_consume_token(REFUSE);
90 break;
91 case REJECT:
92 t = jj_consume_token(REJECT);
93 break;
94 case REQUEST:
95 t = jj_consume_token(REQUEST);
96 break;
97 case REQUEST_WHEN:
98 t = jj_consume_token(REQUEST_WHEN);
99 break;
100 case REQUEST_WHENEVER:
101 t = jj_consume_token(REQUEST_WHENEVER);
102 break;
103 case REQUEST_FORWARD:
104 t = jj_consume_token(REQUEST_FORWARD);
105 break;
106 case SUBSCRIBE:
107 t = jj_consume_token(SUBSCRIBE);
108 break;
109 default:
110 jj_consume_token(-1);
111 throw new ParseException();
112 }
113 {if (true) return t.image;}
114 throw new Error("Missing return statement in function");
115 }
116
117 final public void MessageParameter(Performative msg) throws ParseException {
118 String s = null;
119 Token t = null;
120 Hashtable table = null;
121 Vector receivers = null;
122 switch (jj_nt.kind) {
123 case SENDER:
124 jj_consume_token(SENDER);
125 s = AgentName();
126 msg.setSender(s);
127 break;
128 case RECEIVER:
129 jj_consume_token(RECEIVER);
130 receivers = RecipientExpr();
131 msg.setReceivers(receivers);
132 break;
133 case CONTENT:
134 jj_consume_token(CONTENT);
135 s = Expression();
136 msg.setContent(s);
137 break;
138 case REPLY_TO:
139 jj_consume_token(REPLY_TO);
140 s = Expression();
141
142 msg.setReplyTo (s);
143 break;
144 case REPLY_WITH:
145 jj_consume_token(REPLY_WITH);
146 s = Expression();
147 msg.setReplyWith(s);
148 break;
149 case REPLY_BY:
150 jj_consume_token(REPLY_BY);
151 t = jj_consume_token(DATE_TIME);
152 msg.setReplyBy(t.image);
153 break;
154 case IN_REPLY_TO:
155 jj_consume_token(IN_REPLY_TO);
156 s = Expression();
157 msg.setInReplyTo(s);
158 break;
159 case ENVELOPE:
160 jj_consume_token(ENVELOPE);
161 table = KeyValuePairList();
162 msg.setEnvelope(table);
163 break;
164 case LANGUAGE:
165 jj_consume_token(LANGUAGE);
166 s = Expression();
167 msg.setLanguage(s);
168 break;
169 case ONTOLOGY:
170 jj_consume_token(ONTOLOGY);
171 s = Expression();
172 msg.setOntology(s);
173 break;
174 case PROTOCOL:
175 jj_consume_token(PROTOCOL);
176 t = jj_consume_token(WORD);
177 msg.setProtocol(t.image);
178 break;
179 case CONVERSATION_ID:
180 jj_consume_token(CONVERSATION_ID);
181 s = Expression();
182 msg.setConversationId(s);
183 break;
184 default:
185 jj_consume_token(-1);
186 throw new ParseException();
187 }
188 }
189
190 final public String Expression() throws ParseException {
191 String s = "";
192 Token t = null;
193 String s1;
194 switch (jj_nt.kind) {
195 case WORD:
196 t = jj_consume_token(WORD);
197 s = t.image;
198 break;
199 case LITERAL:
200 t = jj_consume_token(LITERAL);
201 s = Misc.literalToString(t.image);
202 break;
203 case INTEGER:
204 t = jj_consume_token(INTEGER);
205 s = t.image;
206 break;
207 case REAL:
208 t = jj_consume_token(REAL);
209 s = t.image;
210 break;
211 case LBRACKET:
212 jj_consume_token(LBRACKET);
213 label_2:
214 while (true) {
215 s1 = Expression();
216 s += " " + s1;
217 switch (jj_nt.kind) {
218 case LBRACKET:
219 case WORD:
220 case INTEGER:
221 case REAL:
222 case LITERAL:
223 ;
224 break;
225 default:
226 break label_2;
227 }
228 }
229 jj_consume_token(RBRACKET);
230 s = "(" + s + ")";
231 break;
232 default:
233 jj_consume_token(-1);
234 throw new ParseException();
235 }
236 {if (true) return s.trim();}
237 throw new Error("Missing return statement in function");
238 }
239
240 final public Hashtable KeyValuePairList() throws ParseException {
241 Hashtable table = new Hashtable();
242 String value = null;
243 Token t;
244 jj_consume_token(LBRACKET);
245 label_3:
246 while (true) {
247 switch (jj_nt.kind) {
248 case LBRACKET:
249 ;
250 break;
251 default:
252 break label_3;
253 }
254 jj_consume_token(LBRACKET);
255 t = jj_consume_token(WORD);
256 value = Expression();
257 jj_consume_token(RBRACKET);
258 table.put(t.image,value);
259 }
260 jj_consume_token(RBRACKET);
261 {if (true) return table;}
262 throw new Error("Missing return statement in function");
263 }
264
265 final public Vector RecipientExpr() throws ParseException {
266 Vector result = new Vector();
267 String name = null;
268 switch (jj_nt.kind) {
269 case WORD:
270 name = AgentName();
271 result.addElement(name);
272 break;
273 case LBRACKET:
274 jj_consume_token(LBRACKET);
275 label_4:
276 while (true) {
277 name = AgentName();
278 result.addElement(name);
279 switch (jj_nt.kind) {
280 case WORD:
281 ;
282 break;
283 default:
284 break label_4;
285 }
286 }
287 jj_consume_token(RBRACKET);
288 break;
289 default:
290 jj_consume_token(-1);
291 throw new ParseException();
292 }
293 {if (true) return result;}
294 throw new Error("Missing return statement in function");
295 }
296
297 final public String AgentName() throws ParseException {
298 String s = null;
299 Token t = null;
300 /***** good 'ol fashioned zeus */
301 t = jj_consume_token(WORD);
302 s = t.image;
303 switch (jj_nt.kind) {
304 case 52:
305 jj_consume_token(52);
306 t = jj_consume_token(WORD);
307 s += "@" + t.image;
308 break;
309 default:
310 ;
311 }
312 {if (true) return s;}
313 throw new Error("Missing return statement in function");
314 }
315
316 public PerformativeParserTokenManager token_source;
317 ASCII_CharStream jj_input_stream;
318 public Token token, jj_nt;
319
320 public PerformativeParser(java.io.InputStream stream) {
321 jj_input_stream = new ASCII_CharStream(stream, 1, 1);
322 token_source = new PerformativeParserTokenManager(jj_input_stream);
323 token = new Token();
324 token.next = jj_nt = token_source.getNextToken();
325 }
326
327 public void ReInit(java.io.InputStream stream) {
328 jj_input_stream.ReInit(stream, 1, 1);
329 token_source.ReInit(jj_input_stream);
330 token = new Token();
331 token.next = jj_nt = token_source.getNextToken();
332 }
333
334 public PerformativeParser(java.io.Reader stream) {
335 jj_input_stream = new ASCII_CharStream(stream, 1, 1);
336 token_source = new PerformativeParserTokenManager(jj_input_stream);
337 token = new Token();
338 token.next = jj_nt = token_source.getNextToken();
339 }
340
341 public void ReInit(java.io.Reader stream) {
342 jj_input_stream.ReInit(stream, 1, 1);
343 token_source.ReInit(jj_input_stream);
344 token = new Token();
345 token.next = jj_nt = token_source.getNextToken();
346 }
347
348 public PerformativeParser(PerformativeParserTokenManager tm) {
349 token_source = tm;
350 token = new Token();
351 token.next = jj_nt = token_source.getNextToken();
352 }
353
354 public void ReInit(PerformativeParserTokenManager tm) {
355 token_source = tm;
356 token = new Token();
357 token.next = jj_nt = token_source.getNextToken();
358 }
359
360 final private Token jj_consume_token(int kind) throws ParseException {
361 Token oldToken = token;
362 if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
363 else jj_nt = jj_nt.next = token_source.getNextToken();
364 if (token.kind == kind) {
365 return token;
366 }
367 jj_nt = token;
368 token = oldToken;
369 throw generateParseException();
370 }
371
372 final public Token getNextToken() {
373 if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
374 else jj_nt = jj_nt.next = token_source.getNextToken();
375 return token;
376 }
377
378 final public Token getToken(int index) {
379 Token t = token;
380 for (int i = 0; i < index; i++) {
381 if (t.next != null) t = t.next;
382 else t = t.next = token_source.getNextToken();
383 }
384 return t;
385 }
386
387 final public ParseException generateParseException() {
388 Token errortok = token.next;
389 int line = errortok.beginLine, column = errortok.beginColumn;
390 String mess = (errortok.kind == 0) ? tokenImage[0] : errortok.image;
391 return new ParseException("Parse error at line " + line + ", column " + column + ". Encountered: " + mess);
392 }
393
394 final public void enable_tracing() {
395 }
396
397 final public void disable_tracing() {
398 }
399
400 }