|
1
17 package org.eclipse.emf.importer.rose.parser;
18
19 import java.util.List  ;
20 import java.util.Stack ;
21
22
23
47 public class RoseParser
48 {
49 protected RoseLexer lexer;
50 protected RoseNode versionTree;
51 protected RoseNode modelTree;
52 protected String baseId = "";
53 protected Stack idStack = new Stack ();
54 protected boolean isTreeOnly = false;
55 protected boolean isAllowed = true;
56 protected boolean isRoot = true;
57 protected boolean isListMapping = true;
58 protected boolean noLogicalPresentation = false;
59 protected boolean mapProperties = true;
61 public RoseParser(RoseLexer lexer)
62 {
63 this(lexer, false, false);
64 }
65
66 public RoseParser(RoseLexer lexer, boolean isTreeOnly)
67 {
68 this(lexer, isTreeOnly, false);
69 }
70
71 public RoseParser(RoseLexer lexer, boolean isTreeOnly, boolean noPresentation)
72 {
73 this.lexer = lexer;
74 this.isTreeOnly = isTreeOnly;
75 this.noLogicalPresentation = noPresentation;
76 }
77
78 public RoseNode getVersionTree()
79 {
80 return versionTree;
81 }
82
83 public RoseNode getModelTree()
84 {
85 return modelTree;
86 }
87
88 public void parse()
89 {
90 baseId = null;
91 idStack.push(new Integer (0));
92 versionTree = parseExpr("");
93 idStack.push(new Integer (0));
94 baseId = null;
95 modelTree = parseExpr("");
96 }
97
98 public void traverseTree(List path)
99 {
100 RoseNode node = modelTree;
101 if (node == null)
102 {
103 return;
104 }
105
106 for (int i = 0; i < path.size(); i++)
107 {
108 if (node.getRoseNodeType() == RoseNode.STRING)
109 {
110 return;
111 }
112 List nodes = node.getNodes();
113 Integer integ = (Integer )path.get(i);
114 int j = integ.intValue();
115 if (j < 1 || j > nodes.size())
116 break;
117 node = (RoseNode)nodes.get(j - 1);
118 }
119
120 String id = node.getId();
121 String atId = node.getAtId();
122 if (id == null)
123 {
124 id = "";
125 }
126 if (atId == null)
127 {
128 atId = "";
129 }
130 String t1 = "";
131 if (node.getRoseNodeType() == RoseNode.STRING)
132 {
133 t1 = "(STRING)";
134 }
135 else if (node.getRoseNodeType() == RoseNode.LIST)
136 {
137 t1 = "(LIST)";
138 }
139 else if (node.getRoseNodeType() == RoseNode.OBJECT)
140 {
141 t1 = "(OBJECT)";
142 }
143 else if (node.getRoseNodeType() == RoseNode.STRING_SEQ)
144 {
145 t1 = "(STRING_SEQ)";
146 }
147 else if (node.getRoseNodeType() == RoseNode.VALUE)
148 {
149 t1 = "(VALUE)";
150 }
151 System.out.println(t1 + "\t" + node.getKey() + " --- " + node.getValue() + " - " + id + " - " + atId);
152 List nodes = node.getNodes();
153 int count = 1;
154 for (int i = 0; i < nodes.size(); i++)
155 {
156 RoseNode n = (RoseNode)nodes.get(i);
157 String t = "";
158 if (n.getRoseNodeType() == RoseNode.STRING)
159 {
160 t = "(STRING)";
161 }
162 else if (n.getRoseNodeType() == RoseNode.LIST)
163 {
164 t = "(LIST)";
165 }
166 else if (n.getRoseNodeType() == RoseNode.OBJECT)
167 {
168 t = "(OBJECT)";
169 }
170 else if (n.getRoseNodeType() == RoseNode.STRING_SEQ)
171 {
172 t = "(STRING_SEQ)";
173 }
174 else if (n.getRoseNodeType() == RoseNode.VALUE)
175 {
176 t = "(VALUE)";
177 }
178 System.out.println(count + " " + t + "\t" + n.getKey() + " --- " + n.getValue());
179 count++;
180 }
181 }
182
183 private RoseNode parseObject(String key)
184 {
185 Integer topInt = (Integer )idStack.pop();
186 int top = topInt.intValue();
187 idStack.push(new Integer (++top));
188 idStack.push(new Integer (0));
189 if (baseId == null)
190 {
191 baseId = "id";
192 }
193 else
194 {
195 baseId += ".";
196 baseId += topInt.toString();
197 }
198 RoseToken tok = lexer.getNext();
199 if (tok.getType() != RoseToken.OBJECT)
200 {
201 System.out.println(" Parsing error in parseObject - expecting object token");
202 return null;
203 }
204 tok = lexer.getNext();
205 if (tok.getType() != RoseToken.STRING)
206 {
207 System.out.println(" Parsing error in parseObject - expecting string");
208 return null;
209 }
210 String label = tok.getValue();
211 RoseNode root = null;
212 if (isTreeOnly)
213 {
214 if (key.equals("root_usecase_package") || key.equals("root_subsystem") || !mapProperties && key.equals("properties")
215 && label.equals("Properties"))
216 {
217 isListMapping = false;
218 }
219 else if (key.equals("root_category") || key.equals("process_structure") && label.equals("Processes"))
220 {
221 isListMapping = true;
222 }
223 }
224 root = new RoseNode(key, label, RoseNode.OBJECT);
225 root.setId(baseId);
226 while (true)
227 {
228 tok = lexer.peekNext();
229 if (tok.getType() == RoseToken.RIGHT_PAREN)
230 break;
231 else
232 tok = lexer.getNext();
233 if (tok.getType() != RoseToken.KEY)
234 {
235 System.out.println(" Parsing error in parseObject - expecting key " + tok.lineNum);
236 return null;
237 }
238 String pairKey = tok.getValue();
239 RoseNode node = parseExpr(pairKey);
240 if (isTreeOnly)
241 {
242 if (root != null && node != null)
243 {
244 root.addNode(node);
245 }
246 }
247 else
248 {
249 if (node == null)
250 {
251 return null;
252 }
253 root.addNode(node);
254 }
255 }
256 idStack.pop();
257 if (baseId.lastIndexOf('.') > 0)
258 {
259 baseId = baseId.substring(0, baseId.lastIndexOf('.'));
260 }
261 return root;
262 }
263
264 private RoseNode parseValue(String key)
265 {
266 Integer topInt = (Integer )idStack.pop();
267 int top = topInt.intValue();
268 idStack.push(new Integer (++top));
270 idStack.push(new Integer (0));
271 if (baseId == null)
272 {
273 baseId = "id";
274 }
275 else
276 {
277 baseId += ".";
278 baseId += topInt.toString();
279 }
280 RoseToken tok = lexer.getNext();
281 if (tok.getType() != RoseToken.VALUE)
282 {
283 System.out.println(" Parsing error in parseValue - expecting value token");
284 return null;
285 }
286 tok = lexer.getNext();
287 if (tok.getType() != RoseToken.STRING)
288 {
289 System.out.println(" Parsing error in parseValue - expecting string");
290 return null;
291 }
292 String label = tok.getValue();
293 RoseNode root = null;
294 root = new RoseNode(key, label, RoseNode.VALUE);
295 root.setId(baseId);
296 RoseNode node = parseS_prime("");
297 if (isTreeOnly)
298 {
299 if (root != null && node != null)
300 {
301 root.addNode(node);
302 }
303 }
304 else
305 {
306 if (node == null)
307 {
308 return null;
309 }
310 root.addNode(node);
311 }
312 idStack.pop();
313 if (baseId.lastIndexOf('.') > 0)
314 {
315 baseId = baseId.substring(0, baseId.lastIndexOf('.'));
316 }
317 return root;
318 }
319
320 private RoseNode parseExpr(String key)
321 {
322 RoseToken tok = lexer.peekNext();
323 if (tok.getType() == RoseToken.LEFT_PAREN)
324 {
325 tok = lexer.getNext();
326 RoseNode root;
327 tok = lexer.peekNext();
328 if (tok.getType() == RoseToken.OBJECT)
329 {
330 root = parseObject(key);
331 if (!isTreeOnly)
332 {
333 if (root == null)
334 return null;
335 }
336 }
337 else if (tok.getType() == RoseToken.VALUE)
338 {
339 root = parseValue(key);
340 if (!isTreeOnly)
341 {
342 if (root == null)
343 {
344 return null;
345 }
346 }
347 }
348 else if (tok.getType() == RoseToken.LIST)
349 {
350 root = parseList(key);
351 if (!isTreeOnly)
352 {
353 if (root == null)
354 return null;
355 }
356 }
357 else
358 {
359 System.out.println(" Parsing error in parseExpr - expecting object or list");
360 return null;
361 }
362 tok = lexer.getNext();
363 if (tok.getType() != RoseToken.RIGHT_PAREN)
364 {
365 System.out.println(" Parsing error in parseExpr - expecting right parenthesis");
366 return null;
367 }
368 return root;
369 }
370 else
371 {
372 return parseS_prime(key);
373 }
374 }
375
376 private RoseNode parseS_prime(String key)
377 {
378 RoseToken tok = lexer.peekNext();
379 if (tok.getType() == RoseToken.STRING)
380 {
381 tok = lexer.getNext();
382 RoseNode root = null;
383 root = new RoseNode(key, tok.getValue(), RoseNode.STRING);
384 return root;
385 }
386 else if (tok.getType() == RoseToken.VERTICAL_BAR)
387 {
388 RoseNode root = null;
389 root = new RoseNode(key, "", RoseNode.STRING_SEQ);
390 while (true)
391 {
392 tok = lexer.peekNext();
393 if (tok.getType() == RoseToken.VERTICAL_BAR)
394 {
395 tok = lexer.getNext();
396 }
397 else
398 {
399 break;
400 }
401 tok = lexer.getNext();
402 if (tok.getType() != RoseToken.STRING)
403 {
404 System.out.println(" Parsing error in parseS_prime - expecting string");
405 return null;
406 }
407
408 RoseNode node = null;
409 node = new RoseNode("", tok.getValue(), RoseNode.STRING);
410 if (root != null)
411 {
412 root.addNode(node);
413 }
414 }
415 return root;
416 }
417 else
418 {
419 lexer.printNeighbors();
420 System.out.println(" Parsing error in parseS_prime - expecting string or | " + tok.lineNum);
421 return null;
422 }
423 }
424
425 private RoseNode parseList(String key)
426 {
427 boolean wasAllowed = isAllowed;
428
429 if (noLogicalPresentation)
430 {
431 if (key.equals("logical_presentations"))
432 {
433 isAllowed = false;
434 }
435 else
436 {
437 isAllowed = true;
438 }
439 }
440 else
441 {
442 isAllowed = true;
443 }
444
445 if (!isListMapping)
446 {
447 isAllowed = false;
448 }
449 RoseNode root = null;
450 RoseToken tok;
451 tok = lexer.getNext();
452 if (tok.getType() != RoseToken.LIST)
453 {
454 System.out.println(" Parsing error in parseList - expecting list token");
455 return null;
456 }
457 tok = lexer.getNext();
458 if (tok.getType() != RoseToken.STRING)
459 {
460 System.out.println(" Parsing error in parseList - expecting string");
461 return null;
462 }
463 String label = tok.getValue();
464 tok = lexer.peekNext();
465 if (tok.getType() == RoseToken.LEFT_PAREN)
466 {
467 root = null;
468 if (!isTreeOnly || isAllowed)
469 {
470 root = new RoseNode(key, label, RoseNode.LIST);
471 }
472 while (true)
473 {
474 tok = lexer.getNext();
475 if (tok.getType() != RoseToken.LEFT_PAREN)
476 {
477 System.out.println(" Parsing error in parseList - expecting left parenthesis");
478 return null;
479 }
480 RoseNode node = parseObject("");
481 if (isTreeOnly)
482 {
483 if (root != null && node != null)
484 {
485 root.addNode(node);
486 }
487 }
488 else
489 {
490 if (node == null)
491 {
492 return null;
493 }
494 root.addNode(node);
495 }
496 tok = lexer.getNext();
497 if (tok.getType() != RoseToken.RIGHT_PAREN)
498 {
499 System.out.println(" Parsing error in parseList - expecting right parenthesis");
500 return null;
501 }
502 tok = lexer.peekNext();
503 if (tok.getType() == RoseToken.RIGHT_PAREN)
504 {
505 break;
506 }
507 }
508 }
509 else if (tok.getType() == RoseToken.RIGHT_PAREN)
510 {
511 root = null;
512 if (!isTreeOnly || isAllowed)
513 {
514 root = new RoseNode(key, label, RoseNode.LIST);
515 }
516 }
517 else if (tok.getType() == RoseToken.STRING || tok.getType() == RoseToken.VERTICAL_BAR)
518 {
519 root = null;
520 if (!isTreeOnly || isAllowed)
521 {
522 root = new RoseNode(key, label, RoseNode.LIST);
523 }
524 while (true)
525 {
526 tok = lexer.peekNext();
527 if (tok.getType() != RoseToken.STRING && tok.getType() != RoseToken.VERTICAL_BAR)
528 {
529 System.out.println(" Parsing error in parseList - expecting string or |");
530 return null;
531 }
532 RoseNode node = null;
533 node = parseS_prime("");
534 if (root != null)
535 {
536 root.addNode(node);
537 }
538 tok = lexer.peekNext();
539 if (tok.getType() == RoseToken.RIGHT_PAREN)
540 {
541 break;
542 }
543 }
544 }
545 else
546 {
547 lexer.getNext();
548 System.out.println(" Parsing error in parseList - expecting left/right parenthesis or string or | " + tok.lineNum);
549 root = null;
550 }
551
552 isAllowed = wasAllowed;
553 return root;
554 }
555 }
556 |
Popular Tags |
Java API By Example, From Geeks To Geeks.