Source code: org/sablecc/sablecc/ResolveTransformIds.java
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2 * This file is part of SableCC. *
3 * See the file "LICENSE" for copyright information and the *
4 * terms and conditions for copying, distribution and *
5 * modification of SableCC. *
6 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
7
8 package org.sablecc.sablecc;
9
10 import org.sablecc.sablecc.analysis.*;
11 import org.sablecc.sablecc.node.*;
12 import java.util.*;
13 import java.io.*;
14
15 /*
16 * ResolveTransformIds
17 *
18 * This class computes semantic verifications for alternative transformations
19 * in Production section. It makes sure that all transformations specified
20 * for an alternative match with their corresponding prod_transform but also
21 * the alternative transformation is itself correct.
22 */
23
24 public class ResolveTransformIds extends DepthFirstAdapter
25 {
26
27 private ResolveAstIds transformIds;
28 private ResolveAltIds altIds;
29 private ResolveProdTransformIds prodTransformIds;
30
31 private int nbTransformAlt = 0;
32 private int nbTransformProd = 0;
33 private String currentAstAlt;
34 private String currentAstProd;
35 private String currentProd;
36 private String currentAlt;
37 private String currentAstProdName;
38
39 //This Map contains the type of any term of alternative transformation(altTransform)
40 public final Map altTransformElemTypes = new TypedHashMap(
41 NodeCast.instance,
42 StringCast.instance);
43
44 public final Map mapSimpleTermProdTransformation = new TypedHashMap(
45 StringCast.instance,
46 ListCast.instance);
47
48 public final Map simpleTermOrsimpleListTermTypes = new TypedHashMap(
49 NodeCast.instance,
50 StringCast.instance);
51
52 public ResolveTransformIds(ResolveAstIds ast_ids, ResolveAltIds alt_ids, ResolveProdTransformIds p_ids)
53 {
54 transformIds = ast_ids;
55 altIds = alt_ids;
56 prodTransformIds = p_ids;
57 }
58
59 public ResolveProdTransformIds getProdTransformIds()
60 {
61 return prodTransformIds;
62 }
63
64 public void inAProd(final AProd production)
65 {
66 nbTransformProd = 0;
67 currentProd = (String)altIds.ids.names.get(production);
68
69 if(production.getArrow() != null)
70 {
71 nbTransformProd = production.getProdTransform().size();
72 }
73 }
74
75 private LinkedList listCurrentAltGlobal;
76 private LinkedList listCurrentAlt;
77 private LinkedList listOfListCurrentAlt;
78
79 public void inAParsedAlt(AParsedAlt nodeAlt)
80 {
81 nbTransformAlt = 0;
82
83 currentAlt = (String)altIds.ids.names.get(nodeAlt);
84 listCurrentAltGlobal = (LinkedList)((LinkedList)altIds.alts_elemsGlobal.get(currentAlt)).clone();
85 listCurrentAlt = (LinkedList)((LinkedList)altIds.alts_elems.get(currentAlt)).clone();
86 listOfListCurrentAlt = (LinkedList)((LinkedList)altIds.alts_elems_list.get(currentAlt)).clone();
87 }
88
89 public void inAAltTransform(AAltTransform node)
90 {
91 if(node.getTerms().size() == 0)
92 {
93 altTransformElemTypes.put(node, "nothing");
94 }
95 else
96 {
97 nbTransformAlt = node.getTerms().size();
98 }
99 }
100
101 public void outAAltTransform(AAltTransform node)
102 {
103 if(nbTransformAlt != nbTransformProd)
104 {
105 error10( node.getRBrace() );
106 }
107 }
108
109 public void outAParsedAlt(AParsedAlt node)
110 {
111 lastSimpleTerm = null;
112
113 listCurrentAltGlobal = null;
114 listCurrentAlt = null;
115 listOfListCurrentAlt = null;
116 mapSimpleTermProdTransformation.clear();
117 }
118
119 public void outANewTerm(ANewTerm node)
120 {
121 LinkedList list = (LinkedList)prodTransformIds.prod_transforms.get(currentProd);
122 AProdName prodNameNode = (AProdName)node.getProdName();
123
124 currentAstProd = "P" + ResolveIds.name(prodNameNode.getId().getText());
125 currentAstProdName = prodNameNode.getId().getText();
126
127 if(prodNameNode.getProdNameTail() != null)
128 {
129 TId prodNameTailNode = prodNameNode.getProdNameTail();
130 currentAstAlt = "A" + ResolveIds.name(prodNameTailNode.getText()) + ResolveIds.name(prodNameNode.getId().getText());
131 }
132 else
133 {
134 currentAstAlt = "A" + ResolveIds.name(prodNameNode.getId().getText());
135 }
136
137 String currentastProdName;
138 if(currentAstProdName.startsWith("P."))
139 {
140 currentastProdName = currentAstProdName.substring(2);
141 }
142 else
143 {
144 currentastProdName = currentAstProdName;
145 }
146
147 if(transformIds.ast_prods.get(currentAstProd) == null)
148 {
149 error15(((AProdName)node.getProdName()).getId(), ((AProdName)node.getProdName()).getId().getText());
150 }
151
152 if(transformIds.ast_alts.get(currentAstAlt) == null)
153 {
154 error14(((AProdName)node.getProdName()).getId(), currentAstAlt);
155 }
156
157 int sizeNewTerm = 0;
158 if(node.getParams().size() > 0)
159 {
160 sizeNewTerm = node.getParams().size();
161 }
162
163 int sizeAstAlt = 0;
164 if( ((AAstAlt)transformIds.ast_alts.get(currentAstAlt) ).getElems() != null)
165 {
166 sizeAstAlt = ( (LinkedList)((AAstAlt)transformIds.ast_alts.get(currentAstAlt) ).getElems()).size();
167 }
168
169 if(sizeNewTerm != sizeAstAlt)
170 {
171 error17( ((AProdName)node.getProdName()).getId(), currentAstAlt);
172 }
173
174 AProdName aProdName = (AProdName)node.getProdName();
175
176 String type = "P" + ResolveIds.name(aProdName.getId().getText());
177
178 altTransformElemTypes.put(node, type);
179
180 AAstAlt astAlt = (AAstAlt)transformIds.ast_alts.get(currentAstAlt);
181
182 if(node.getParams().size() > 0 && astAlt.getElems().size() > 0)
183 {
184 Object elemsTable[] = astAlt.getElems().toArray();
185 Object paramsTable[] = node.getParams().toArray();
186
187 String termType, elemType;
188
189 for(int j=0; j<elemsTable.length; j++)
190 {
191 termType = (String)altTransformElemTypes.get(paramsTable[j]);
192 elemType = (String)transformIds.ast_elemTypes.get(elemsTable[j]);
193
194 if( (((AElem)elemsTable[j]).getUnOp() != null) &&
195 ( (((AElem)elemsTable[j]).getUnOp() instanceof AStarUnOp) || (((AElem)elemsTable[j]).getUnOp() instanceof APlusUnOp) ) )
196 {
197 elemType = "L" + elemType;
198 }
199 if((!elemType.startsWith("L") && !termType.equals("null") && !termType.equals(elemType)) ||
200 (elemType.startsWith("L") && !termType.equals("Lnull") && !termType.equals(elemType)) )
201 {
202 error21(node.getLPar(), elemType, termType);
203 }
204 }
205 }
206 }
207
208 public void outANewListTerm(ANewListTerm node)
209 {
210 LinkedList list = (LinkedList)prodTransformIds.prod_transforms.get(currentProd);
211 AProdName prodNameNode = (AProdName)node.getProdName();
212
213 currentAstProdName = prodNameNode.getId().getText();
214 currentAstProd = "P" + ResolveIds.name(currentAstProdName);
215
216 if(prodNameNode.getProdNameTail() != null)
217 {
218 TId prodNameTailNode = prodNameNode.getProdNameTail();
219 currentAstAlt = "A" + ResolveIds.name(prodNameTailNode.getText()) + ResolveIds.name(prodNameNode.getId().getText());
220 }
221 else
222 {
223 currentAstAlt = "A" + ResolveIds.name(prodNameNode.getId().getText());
224 }
225
226 String currentastProdName;
227 if(currentAstProdName.startsWith("P."))
228 {
229 currentastProdName = currentAstProdName.substring(2);
230 }
231 else
232 {
233 currentastProdName = currentAstProdName;
234 }
235
236 if(transformIds.ast_prods.get(currentAstProd) == null)
237 {
238 error15(((AProdName)node.getProdName()).getId(), ((AProdName)node.getProdName()).getId().getText());
239 }
240
241 if(transformIds.ast_alts.get(currentAstAlt) == null)
242 {
243 error14(((AProdName)node.getProdName()).getId(), currentAstAlt);
244 }
245
246 int sizeNewTerm = 0;
247 if(node.getParams().size() > 0)
248 {
249 sizeNewTerm = node.getParams().size();
250 }
251
252 int sizeAstAlt = 0;
253 if( ((AAstAlt)transformIds.ast_alts.get(currentAstAlt) ).getElems() != null)
254 {
255 sizeAstAlt = ( (LinkedList)((AAstAlt)transformIds.ast_alts.get(currentAstAlt) ).getElems()).size();
256 }
257
258 if(sizeNewTerm != sizeAstAlt)
259 {
260 error17( ((AProdName)node.getProdName()).getId(), currentAstAlt);
261 }
262
263 /***********************************************************************************************************************************/
264 AProdName aProdName = (AProdName)node.getProdName();
265
266 String type = "P" + ResolveIds.name(aProdName.getId().getText());
267
268 altTransformElemTypes.put(node, type);
269
270 AAstAlt astAlt = (AAstAlt)transformIds.ast_alts.get(currentAstAlt);
271
272 if(node.getParams().size() > 0 && astAlt.getElems().size() > 0)
273 {
274 Object elemsTable[] = astAlt.getElems().toArray();
275 Object paramsTable[] = node.getParams().toArray();
276
277 String termType, elemType;
278
279 for(int j=0; j<elemsTable.length; j++)
280 {
281 termType = (String)altTransformElemTypes.get(paramsTable[j]);
282 elemType = (String)transformIds.ast_elemTypes.get(elemsTable[j]);
283
284 if( (((AElem)elemsTable[j]).getUnOp() != null) &&
285 ( (((AElem)elemsTable[j]).getUnOp() instanceof AStarUnOp) || (((AElem)elemsTable[j]).getUnOp() instanceof APlusUnOp) ) )
286 {
287 elemType = "L" + elemType;
288 }
289 if((!elemType.startsWith("L") && !termType.equals("null") && !termType.equals(elemType)) ||
290 (elemType.startsWith("L") && !termType.equals("Lnull") && !termType.equals(elemType)) )
291 {
292 error21(node.getLPar(), elemType, termType);
293 }
294 }
295 }
296 /***********************************************************************************************************************************/
297 }
298
299 public void outAListTerm(AListTerm node)
300 {
301 if( (node.getListTerms() != null) && (node.getListTerms().size() != 0) )
302 {
303 Object temp[] = node.getListTerms().toArray();
304 String firstTermType = (String)altTransformElemTypes.get(temp[0]);
305
306 for(int i=1; i<temp.length; i++)
307 {
308 String termType = (String)altTransformElemTypes.get(temp[i]);
309
310 if( ( !termType.startsWith("L") && !firstTermType.startsWith("L") && !termType.equals(firstTermType) ) ||
311 ( termType.startsWith("L") && !firstTermType.startsWith("L") && !(termType.substring(1)).equals(firstTermType) ) ||
312 ( !termType.startsWith("L") && firstTermType.startsWith("L") && !(firstTermType.substring(1)).equals(termType) ) ||
313 ( termType.startsWith("L") && firstTermType.startsWith("L") && !termType.equals(firstTermType) ) )
314 {
315 error20(node.getLBkt());
316 }
317 }
318
319 if(!firstTermType.startsWith("L"))
320 {
321 altTransformElemTypes.put(node, "L" + firstTermType);
322 }
323 else
324 {
325 altTransformElemTypes.put(node, firstTermType);
326 }
327 }
328 else
329 {
330 altTransformElemTypes.put(node, "Lnull");
331 }
332 }
333
334 private LinkedList listL;
335 private LinkedList listP;
336 private String lastSimpleTerm;
337
338 public void inASimpleTerm(ASimpleTerm node)
339 {
340 String name = node.getId().getText();
341 String elemType = (String)transformIds.astIds.altsElemNameTypes.get( currentAlt+"."+node.getId().getText() );
342 boolean okTermtail = false;
343 String tmpName = name;
344
345 if( (listCurrentAltGlobal == null) || !listCurrentAltGlobal.contains(name) )
346 {
347 /************************************/error11(node.getId(), name);
348 }
349 else
350 {
351 ListIterator iter = null;
352 iter = listCurrentAltGlobal.listIterator();
353
354 while(iter.hasNext())
355 {
356 if( name.equals((String)iter.next()) )
357 {
358 if( node.getSimpleTermTail() == null )
359 {
360 iter.remove();
361 }
362 break;
363 }
364 }
365 }
366
367 if( (listCurrentAlt == null) || !listCurrentAlt.contains(name) )
368 {
369 error11(node.getId(), name);
370 }
371 else
372 {
373 ListIterator iter = null;
374 iter = listCurrentAlt.listIterator();
375
376 while(iter.hasNext())
377 {
378 if( name.equals((String)iter.next()) )
379 {
380 if( node.getSimpleTermTail() == null )
381 {
382 iter.remove();
383 }
384 break;
385 }
386 }
387 }
388
389 int position = 0;
390
391 if(node.getSpecifier() != null)
392 {
393 if(node.getSpecifier() instanceof ATokenSpecifier)
394 {
395 if(elemType != null)
396 {
397 error19(node.getId());
398 }
399
400 name = "T" + ResolveIds.name(node.getId().getText());
401 //A token can't have term tail
402 if(node.getSimpleTermTail() != null)
403 {
404 error12(node.getId());
405 }
406
407 altTransformElemTypes.put(node, "T" + ResolveIds.name(node.getId().getText()) );
408 position = 0;
409 }
410 else
411 {
412 //the id is an element name
413 if(elemType != null)
414 {
415 error19(node.getId());
416 }
417
418 name = "P" + ResolveIds.name(node.getId().getText());
419
420 if( mapSimpleTermProdTransformation.get(currentAlt+"."+tmpName) == null )
421 {
422 if(prodTransformIds.prod_transforms.get(name) != null)
423 {
424 listL = (LinkedList)((LinkedList)prodTransformIds.prod_transforms.get(name)).clone();
425 mapSimpleTermProdTransformation.put(currentAlt+"."+tmpName, listL);
426 }
427 }
428
429 listCurrentAlt.remove(lastSimpleTerm);
430
431 lastSimpleTerm = name;
432
433 boolean blistL = false;
434
435 if( (listL!= null) && (listL.size()==1) && listL.contains(node.getId().getText()) )
436 {
437 blistL = true;
438 }
439
440 //the production is transformed but it appears without a term tail.
441 if( (node.getSimpleTermTail() == null) && (listL != null) && !blistL)
442 {
443 error9(node.getId(), node.getId().getText());
444 }
445
446 if( node.getSimpleTermTail() == null )
447 {
448 position = 0;
449 }
450
451 if( node.getSimpleTermTail() != null )
452 {
453 String strTermTail = node.getSimpleTermTail().getText();
454
455 if( ((listL == null) || !listL.contains( strTermTail ) ) )
456 {
457 error13(node.getId(), node.getId().getText(), strTermTail);
458 }
459 else
460 {
461 ListIterator iter = null;
462 iter = listL.listIterator();
463
464 position = listL.indexOf(strTermTail);
465 while(iter.hasNext())
466 {
467 if( strTermTail.equals((String)iter.next()) )
468 {
469 iter.remove();
470 break;
471 }
472 }
473 }
474 }
475 //The Type of the element without his eventual termtail (term.termtail :: (type of term))
476 simpleTermOrsimpleListTermTypes.put(node, "P" + ResolveIds.name(node.getId().getText()));
477
478 if(node.getSimpleTermTail() == null)
479 {
480 altTransformElemTypes.put(node, "P" + ResolveIds.name(node.getId().getText()) );
481 }
482 else
483 {
484 String termTail = node.getSimpleTermTail().getText();
485 String typeOfTerm = (String)prodTransformIds.prodTransformElemTypesString.get(name+"."+termTail);
486 if(typeOfTerm.startsWith("L"))
487 {
488 typeOfTerm = typeOfTerm.substring(1);
489 }
490 altTransformElemTypes.put(node, typeOfTerm) ;
491 }
492 }
493 }
494 //The specifier is null
495 else
496 {
497 String type;
498
499 //The element is a token
500 if( ( (elemType != null) && elemType.startsWith("T") ) ||
501 ( (elemType == null) && transformIds.astIds.tokens.get("T" + ResolveIds.name(node.getId().getText())) != null ) )
502 {
503 if(node.getSimpleTermTail() != null)
504 {
505 error12(node.getId());
506 }
507
508 if(elemType != null)
509 {
510 altTransformElemTypes.put(node, elemType);
511 }
512 else
513 {
514 altTransformElemTypes.put(node, "T" + ResolveIds.name(node.getId().getText()) );
515 }
516 position = 0;
517 }
518 //The element is a production
519 else
520 {
521 listL = null;
522
523 name = "P" + ResolveIds.name(node.getId().getText());
524
525 if(!name.equals(lastSimpleTerm) )
526 {
527 if(elemType != null)
528 {
529 if( mapSimpleTermProdTransformation.get(currentAlt+"."+tmpName) == null)
530 {
531 if(prodTransformIds.prod_transforms.get(elemType) != null)
532 {
533 listL = (LinkedList)((LinkedList)prodTransformIds.prod_transforms.get(elemType)).clone();
534 mapSimpleTermProdTransformation.put(currentAlt+"."+tmpName, listL);
535 }
536 }
537 else
538 {
539 listL = (LinkedList)mapSimpleTermProdTransformation.get(currentAlt+"."+tmpName);
540 }
541 }
542 if( mapSimpleTermProdTransformation.get(currentAlt+".P"+tmpName) == null )
543 {
544 listP = (LinkedList)prodTransformIds.prod_transforms.get(name);
545 if(prodTransformIds.prod_transforms.get(name) != null)
546 {
547 listP = (LinkedList)((LinkedList)prodTransformIds.prod_transforms.get(name)).clone();
548 mapSimpleTermProdTransformation.put(currentAlt+".P"+tmpName, listP);
549 }
550 }
551 else
552 {
553 listP = (LinkedList)mapSimpleTermProdTransformation.get(currentAlt+".P"+tmpName);
554 }
555
556 listCurrentAlt.remove(lastSimpleTerm);
557 }
558
559 boolean blistL = false;
560
561 if( ( (elemType != null) && (listL!= null) && (listL.size()==1) && ResolveIds.name((String)listL.getFirst()).equals(elemType.substring(1)) ) ||
562 ( (elemType == null) && (listP!= null) && (listP.size()==1) && listP.contains(node.getId().getText()) ) )
563 {
564 blistL = true;
565 }
566
567 //the production is transformed but it appears without a term tail.
568 if( (node.getSimpleTermTail() == null) &&
569 ( (listL != null) || (listP != null) ) && !blistL )
570 {
571 if(elemType != null)
572 {
573 error9(node.getId(), elemType);
574 }
575 else
576 {
577 error9(node.getId(), node.getId().getText());
578 }
579 }
580
581 //simpletermtail doesn't appear in the production transformation
582 if( node.getSimpleTermTail() != null )
583 {
584 okTermtail = true;
585 String strTermTail = node.getSimpleTermTail().getText();
586
587 if( ( (listL == null) || !listL.contains(strTermTail) ) &&
588 ( (listP == null) || !listP.contains(strTermTail) ) )
589 {
590 error13(node.getId(), node.getId().getText(), strTermTail);
591 }
592 else
593 {
594 ListIterator iter = null;
595
596 if(listL != null)
597 {
598 iter = listL.listIterator();
599
600 position = listL.indexOf(strTermTail);
601
602 while(iter.hasNext())
603 {
604 if( strTermTail.equals((String)iter.next()) )
605 {
606 iter.remove();
607 break;
608 }
609 }
610 }
611
612 if(listP != null)
613 {
614 iter = listP.listIterator();
615
616 position = listP.indexOf(strTermTail);
617
618 while(iter.hasNext())
619 {
620 if( strTermTail.equals((String)iter.next()) )
621 {
622 iter.remove();
623 break;
624 }
625 }
626 }
627
628 }
629 }
630
631 if(node.getSimpleTermTail() != null)
632 {
633 String termtail = node.getSimpleTermTail().getText();
634 LinkedList listProdContains = null;
635 if(elemType != null)
636 {
637 listProdContains = (LinkedList)prodTransformIds.mapProdTransformContainsList.get(elemType);
638 }
639 else
640 {
641 listProdContains = (LinkedList)prodTransformIds.mapProdTransformContainsList.get("P" + ResolveIds.name(node.getId().getText()));
642 }
643 }
644 //The Type of the element without his eventual termtail (term.termtail :: (type of term))
645 if(elemType != null)
646 {
647 simpleTermOrsimpleListTermTypes.put(node, elemType);
648 }
649 else
650 {
651 simpleTermOrsimpleListTermTypes.put(node, "P" + ResolveIds.name(node.getId().getText()));
652 }
653
654 if(node.getSimpleTermTail() == null)
655 {
656 if(elemType != null)
657 {
658 altTransformElemTypes.put(node, elemType);
659 }
660 else
661 {
662 altTransformElemTypes.put(node, "P" + ResolveIds.name(node.getId().getText()) );
663 }
664 position = 0;
665 }
666 else
667 {
668 String prodType;
669 if(elemType != null)
670 {
671 prodType = elemType;
672 }
673 else
674 {
675 prodType = "P" + ResolveIds.name(node.getId().getText());
676 }
677
678 String termTail = node.getSimpleTermTail().getText();
679 String typeOfTerm = (String)prodTransformIds.prodTransformElemTypesString.get(prodType+"."+termTail);
680 if(typeOfTerm.startsWith("L"))
681 {
682 typeOfTerm = typeOfTerm.substring(1);
683 }
684 altTransformElemTypes.put(node, typeOfTerm);
685 }
686 }
687 }
688 }
689
690 public void caseANullTerm(ANullTerm node)
691 {
692 altTransformElemTypes.put(node, "null");
693 }
694
695 public void inASimpleListTerm(ASimpleListTerm node)
696 {
697 String name = node.getId().getText();
698 String elemType = (String)transformIds.astIds.altsElemNameTypes.get( currentAlt+"."+node.getId().getText() );
699 String strTermTail;
700 String tmpName = name;
701
702 if( (listCurrentAltGlobal == null) || !listCurrentAltGlobal.contains(name) )
703 {
704 error11(node.getId(), name);
705 }
706 else
707 {
708 ListIterator iter = null;
709 iter = listCurrentAltGlobal.listIterator();
710
711 while(iter.hasNext())
712 {
713 if( name.equals((String)iter.next()) )
714 {
715 if( node.getSimpleTermTail() == null )
716 {
717 iter.remove();
718 }
719 break;
720 }
721 }
722 }
723
724 if( ((listCurrentAlt == null) || !listCurrentAlt.contains(name)) && ((listOfListCurrentAlt == null) || !listOfListCurrentAlt.contains(name)) )
725 {
726 /***********************************************/error11(node.getId(), name);
727 }
728 else
729 {
730 ListIterator iter = null;
731 if( (listCurrentAlt != null) && listCurrentAlt.contains(name) )
732 {
733 iter = listCurrentAlt.listIterator();
734 }
735 else if( (listOfListCurrentAlt != null) && listOfListCurrentAlt.contains(name) )
736 {
737 iter = listOfListCurrentAlt.listIterator();
738 }
739
740 while(iter.hasNext())
741 {
742 if( name.equals((String)iter.next()) )
743 {
744 if( node.getSimpleTermTail() == null )
745 {
746 iter.remove();
747 }
748 break;
749 }
750 }
751 }
752
753 int position = 0;
754
755 if(node.getSpecifier() != null)
756 {
757 //The simpleTerm is a token
758 if(node.getSpecifier() instanceof ATokenSpecifier)
759 {
760 //If the token has a name, then it cannot be referred by this name
761 //preceded by the specifier "T."
762 if(elemType != null)
763 {
764 error19(node.getId());
765 }
766
767 name = "T" + ResolveIds.name(node.getId().getText());
768
769 //this is a simpleTerm which seems to be a token,
770 //so it can't have term tail. (like T.id.termtail)
771 if(node.getSimpleTermTail() != null)
772 {
773 error12(node.getId());
774 }
775 altTransformElemTypes.put(node, "T" + ResolveIds.name(node.getId().getText()) );
776 position = 0;
777 }
778 else
779 {
780 //the id is an element name
781 if(elemType != null)
782 {
783 error19(node.getId());
784 }
785
786 name = "P" + ResolveIds.name(node.getId().getText());
787
788 if( mapSimpleTermProdTransformation.get(currentAlt+"."+tmpName) == null )
789 {
790 if(prodTransformIds.prod_transforms.get(name) != null)
791 {
792 listL = (LinkedList)((LinkedList)prodTransformIds.prod_transforms.get(name)).clone();
793 mapSimpleTermProdTransformation.put(currentAlt+"."+tmpName, listL);
794 }
795 }
796 listCurrentAlt.remove(lastSimpleTerm);
797
798 boolean blistL = false;
799
800 if( (listL!= null) && (listL.size()==1) && listL.contains(node.getId().getText()) )
801 {
802 blistL = true;
803 }
804
805 //the production is transformed but it appears without a term tail.
806 if( (node.getSimpleTermTail() == null) && ( listL != null ) && !blistL )
807 {
808 error9(node.getId(), node.getId().getText());
809 }
810
811 if( node.getSimpleTermTail() == null )
812 {
813 position = 0;
814 }
815
816 //the production is not transformed but it appears with a term tail.
817 if( (node.getSimpleTermTail() != null) )
818 {
819 strTermTail = node.getSimpleTermTail().getText();
820
821 if (((listL == null) || !listL.contains( strTermTail ) ) )
822 {
823 error13(node.getId(), node.getId().getText(), strTermTail);
824 }
825 else
826 {
827 ListIterator iter = null;
828 iter = listL.listIterator();
829
830 position = listL.indexOf(strTermTail);
831 while(iter.hasNext())
832 {
833 if( strTermTail.equals((String)iter.next()) )
834 {
835 iter.remove();
836 break;
837 }
838 }
839 }
840 }
841
842 //The Type of the element without his eventual termtail (term.termtail :: (type of term))
843 simpleTermOrsimpleListTermTypes.put(node, "P" + ResolveIds.name(node.getId().getText()));
844
845 if(node.getSimpleTermTail() == null)
846 {
847 altTransformElemTypes.put(node, "P" + ResolveIds.name(node.getId().getText()) );
848 }
849 else
850 {
851 String termTail = (String) node.getSimpleTermTail().getText();
852 String typeOfTerm = (String)prodTransformIds.prodTransformElemTypesString.get(name+"."+termTail);
853 if(typeOfTerm.startsWith("L"))
854 {
855 typeOfTerm = typeOfTerm.substring(1);
856 }
857 altTransformElemTypes.put(node, typeOfTerm);
858 }
859 }
860 }
861
862 //the element has no specifier
863 else
864 {
865 String type;
866 if( ( (elemType != null) && elemType.startsWith("T") ) ||
867 ( (elemType == null) && transformIds.astIds.tokens.get("T" + ResolveIds.name(node.getId().getText())) != null ) )
868 {
869 //A token can't have term tail
870 if(node.getSimpleTermTail() != null)
871 {
872 error12(node.getId());
873 }
874
875 if(elemType != null)
876 {
877 altTransformElemTypes.put(node, elemType);
878 }
879 else
880 {
881 altTransformElemTypes.put(node, "T" + ResolveIds.name(node.getId().getText()) );
882 }
883 position = 0;
884 }
885 //it seems to be a production without a specifier
886 else
887 {
888 name = "P" + ResolveIds.name(node.getId().getText());
889
890 if(!name.equals(lastSimpleTerm) )
891 {
892 if(elemType != null)
893 {
894 if( mapSimpleTermProdTransformation.get(currentAlt+"."+tmpName) == null)
895 {
896 if(prodTransformIds.prod_transforms.get(elemType) != null)
897 {
898 listL = (LinkedList)((LinkedList)prodTransformIds.prod_transforms.get(elemType)).clone();
899 mapSimpleTermProdTransformation.put(currentAlt+"."+tmpName, listL);
900 }
901 }
902 else
903 {
904 listL = (LinkedList)mapSimpleTermProdTransformation.get(currentAlt+"."+tmpName);
905 }
906 }
907 if( mapSimpleTermProdTransformation.get(currentAlt+".P"+tmpName) == null )
908 {
909 listP = (LinkedList)prodTransformIds.prod_transforms.get(name);
910 if(prodTransformIds.prod_transforms.get(name) != null)
911 {
912 listP = (LinkedList)((LinkedList)prodTransformIds.prod_transforms.get(name)).clone();
913 mapSimpleTermProdTransformation.put(currentAlt+".P"+tmpName, listP);
914 }
915 }
916 else
917 {
918 listP = (LinkedList)mapSimpleTermProdTransformation.get(currentAlt+".P"+tmpName);
919 }
920
921 listCurrentAlt.remove(lastSimpleTerm);
922 }
923
924 boolean blistL = false;
925
926 if( ( (elemType != null) && (listL!= null) && (listL.size()==1) && ResolveIds.name((String)listL.getFirst()).equals(elemType.substring(1)) ) ||
927 ( (elemType == null) && (listP!= null) && (listP.size()==1) && listP.contains(node.getId().getText()) ) )
928 {
929 blistL = true;
930 }
931
932 //the production is transformed but it appears without a term tail.
933 if( (node.getSimpleTermTail() == null) &&
934 ( (listL != null) || (listP != null) ) && !blistL )
935 {
936 if(elemType != null)
937 {
938 error9(node.getId(), elemType);
939 }
940 else
941 {
942 error9(node.getId(), node.getId().getText());
943 }
944 }
945
946 //the production is not transformed but it appears with a term tail.
947 if(node.getSimpleTermTail() != null)
948 {
949 strTermTail = node.getSimpleTermTail().getText();
950
951 if( ( (listL == null) || !listL.contains(strTermTail) ) &&
952 ( (listP == null) || !listP.contains(strTermTail) ) )
953 {
954 error13(node.getId(), node.getId().getText(), node.getSimpleTermTail().getText() );
955 }
956 else
957 {
958 ListIterator iter = null;
959
960 if(listL != null)
961 {
962 iter = listL.listIterator();
963
964 position = listL.indexOf(strTermTail);
965
966 while(iter.hasNext())
967 {
968 if( strTermTail.equals((String)iter.next()) )
969 {
970 iter.remove();
971 break;
972 }
973 }
974 }
975
976 if(listP != null)
977 {
978 iter = listP.listIterator();
979
980 position = listP.indexOf(strTermTail);
981
982 while(iter.hasNext())
983 {
984 if( strTermTail.equals((String)iter.next()) )
985 {
986 iter.remove();
987 break;
988 }
989 }
990 }
991 }
992 }
993
994 if(node.getSimpleTermTail() != null)
995 {
996 String termtail = node.getSimpleTermTail().getText();
997 LinkedList listProdContains = null;
998 LinkedList prodContains = null;
999 if(elemType != null)
1000 {
1001 listProdContains = (LinkedList)prodTransformIds.mapProdTransformContainsList.get(elemType);
1002 prodContains = (LinkedList)prodTransformIds.prod_transforms.get(elemType);
1003 }
1004 else
1005 {
1006 listProdContains = (LinkedList)prodTransformIds.mapProdTransformContainsList.get("P" + ResolveIds.name(node.getId().getText()));
1007 prodContains = (LinkedList)prodTransformIds.prod_transforms.get("P" + ResolveIds.name(node.getId().getText()));
1008 }
1009
1010 LinkedList lst = (LinkedList)altIds.alts_elems_list.get(currentAlt);
1011 }
1012
1013 //The Type of the element without his eventual termtail (term.termtail :: (type of term))
1014
1015 if(elemType != null)
1016 {
1017 simpleTermOrsimpleListTermTypes.put(node, elemType);
1018 }
1019 else
1020 {
1021 simpleTermOrsimpleListTermTypes.put(node, "P" + ResolveIds.name(node.getId().getText()));
1022 }
1023
1024 if(node.getSimpleTermTail() == null)
1025 {
1026 if(elemType != null)
1027 {
1028 altTransformElemTypes.put(node, elemType);
1029 }
1030 else
1031 {
1032 altTransformElemTypes.put(node, "P" + ResolveIds.name(node.getId().getText()) );
1033 }
1034 position = 0;
1035 }
1036 else
1037 {
1038 String prodType;
1039 if(elemType != null)
1040 {
1041 prodType = elemType;
1042 }
1043 else
1044 {
1045 prodType = "P" + ResolveIds.name(node.getId().getText());
1046 }
1047
1048 String termTail = node.getSimpleTermTail().getText();
1049 String typeOfTerm = (String)prodTransformIds.prodTransformElemTypesString.get(prodType+"."+termTail);
1050 if(typeOfTerm.startsWith("L"))
1051 {
1052 typeOfTerm = typeOfTerm.substring(1);
1053 }
1054 altTransformElemTypes.put(node, typeOfTerm);
1055 }
1056 }
1057 }
1058 }
1059
1060 private Object temp1[];
1061 private boolean boolProdTransform;
1062 private boolean firstProduction = false;
1063
1064 public void outAProductions(AProductions node)
1065 {
1066 LinkedList list = node.getProds();
1067 AProd prod = (AProd)list.getFirst();
1068 firstProduction = true;
1069
1070 if( prodTransformIds.listProdTransformList.contains("P"+ ResolveIds.name( prod.getId().getText()) ) )
1071 {
1072 errorFirst(prod.getId());
1073 }
1074
1075 Object temp[] = node.getProds().toArray();
1076 for(int i = 0; i < temp.length; i++)
1077 {
1078
1079 ((PProd) temp[i]).apply(new DepthFirstAdapter()
1080 {
1081 public void inAProd(AProd production)
1082 {
1083 LinkedList prodTransform = production.getProdTransform();
1084 String prodTransformElemType = "";
1085 temp1 = null;
1086 boolProdTransform = false;
1087
1088 if(production.getArrow() != null && prodTransform.size() >= 1)
1089 {
1090 temp1 = prodTransform.toArray();
1091 prodTransformElemType = (String)prodTransformIds.prodTransformElemTypes.get(temp1[0]);
1092 }
1093 else if(production.getArrow() == null)
1094 {
1095 boolProdTransform = true;
1096 String []tab = new String[1];
1097 tab[0] = "P" + ResolveIds.name(production.getId().getText());
1098 temp1 = (Object[])tab;
1099 prodTransformElemType = (String)temp1[0];
1100 }
1101 else
1102 {
1103 boolProdTransform = true;
1104 String []tab = new String[1];
1105 tab[0] = "nothing";
1106 temp1 = (Object[])tab;
1107 prodTransformIds.prodTransformElemTypes.put(prodTransform, "nothing");
1108 prodTransformElemType = (String)temp1[0];
1109 }
1110
1111 if(firstProduction)
1112 {
1113 if( !prodTransformElemType.equals(transformIds.getFirstAstProduction()) )
1114 {
1115 error22();
1116 }
1117 firstProduction = false;
1118 }
1119 }
1120
1121 public void inAAltTransform(AAltTransform node)
1122 {
1123 //LinkedList altTransform = node.getAltTransform();
1124 Object temp3[] = node.getTerms().toArray();
1125
1126 if(temp3.length > 0)
1127 {
1128 for(int k = 0; k < temp3.length; k++)
1129 {
1130 String prodTransformElemType, altTransformTermType;
1131
1132 if(!boolProdTransform)
1133 {
1134 prodTransformElemType = (String)prodTransformIds.prodTransformElemTypes.get(temp1[k]);
1135 }
1136 else
1137 {
1138 prodTransformElemType = (String)temp1[k];
1139 }
1140 altTransformTermType = (String)altTransformElemTypes.get(temp3[k]);
1141
1142 if( !(( prodTransformElemType.startsWith("L") && altTransformTermType.equals("Lnull") ||
1143 altTransformTermType.equals(prodTransformElemType)) ||
1144 ( !prodTransformElemType.startsWith("L") && altTransformTermType.equals("null") ||
1145 altTransformTermType.equals(prodTransformElemType) )) )
1146 {
1147 error21(node.getLBrace(), prodTransformElemType, altTransformTermType);
1148 }
1149 }
1150 }
1151 else
1152 {
1153 String prodTransformElemType = (String)temp1[0];
1154 String altTransformTermType = (String)altTransformElemTypes.get(node);
1155 if(!prodTransformElemType.equals(altTransformTermType))
1156 {
1157 error21(node.getLBrace(), prodTransformElemType, altTransformTermType);
1158 }
1159 }
1160 }
1161 }
1162 );
1163 }
1164 }
1165
1166 private static void error9(Token token, String name)
1167 {
1168 throw new RuntimeException(
1169 "[" + token.getLine() + "," + token.getPos() + "] " +
1170 "production " + name + " was transformed. It can't appear here again");
1171 }
1172
1173 private void error10(Token token)
1174 {
1175 throw new RuntimeException(
1176 "[" + token.getLine() + "," + token.getPos() + "] " +
1177 "this alternative transformation is incorrect because the number of "+
1178 " production transformation and alternatives ones doesn't match");
1179 }
1180
1181 private static void error11(Token token, String name)
1182 {
1183 throw new RuntimeException(
1184 "[" + token.getLine() + "," + token.getPos() + "] " +
1185 name + " must be one of the elements on the left side of the arrow "+
1186 " or is already refered to in this alternative" );
1187 }
1188
1189 private static void error12(Token token)
1190 {
1191 throw new RuntimeException(
1192 "[" + token.getLine() + "," + token.getPos() + "] " +
1193 "tokens are never transformed. This syntax is incorrect");
1194 }
1195
1196 private static void error13(Token token, String prod_name, String name)
1197 {
1198 throw new RuntimeException(
1199 "[" + token.getLine() + "," + token.getPos() + "] " +
1200 "production " + prod_name + " was never transformed to "+name+
1201 " or #"+name+"# cannot be refered by #" + prod_name + "# twice in the same alternative");
1202 }
1203
1204 private static void error14(Token token, String name)
1205 {
1206 throw new RuntimeException(
1207 "[" + token.getLine() + "," + token.getPos() + "] " +
1208 "alternative "+ name +" doesn't exist in section AST");
1209 }
1210
1211 private static void error15(Token token, String name)
1212 {
1213 throw new RuntimeException(
1214 "[" + token.getLine() + "," + token.getPos() + "] " +
1215 "Production "+ name + " doesn't exist in section AST");
1216 }
1217
1218 private static void error16(Token token, String name)
1219 {
1220 throw new RuntimeException(
1221 "[" + token.getLine() + "," + token.getPos() + "] " +
1222 "this transformation is incorrect. The current production "+
1223 "can not be transformed to production "+ name);
1224 }
1225
1226 private static void error17(Token token, String name)
1227 {
1228 throw new RuntimeException(
1229 "[" + token.getLine() + "," + token.getPos() + "] " +
1230 "The number of parameters request for this alternative in "+
1231 "section AST doesn't match");
1232 }
1233
1234 private static void error19(Token token)
1235 {
1236 throw new RuntimeException(
1237 "[" + token.getLine() + "," + token.getPos() + "] " +
1238 "The use of specifier here is not permit");
1239 }
1240
1241 private static void error20(Token token)
1242 {
1243 throw new RuntimeException(
1244 "[" + token.getLine() + "," + token.getPos() + "] " +
1245 "The type of elements in a list must the same");
1246 }
1247
1248 private static void error21(Token token, String prodName, String altName)
1249 {
1250 throw new RuntimeException(
1251 "[" + token.getLine() + "," + token.getPos() + "] " +
1252 "expecting " + prodName + " when " + altName + " was found");
1253 }
1254
1255 private static void error22()
1256 {
1257 throw new RuntimeException(
1258 "The first production transformation must refered to the first production in section AST"
1259 );
1260 }
1261
1262 private static void errorFirst(Token token)
1263 {
1264 throw new RuntimeException(
1265 "[" + token.getLine() + "," + token.getPos() + "] " +
1266 "The first production's transformation must be only one elements without an operator.");
1267 }
1268
1269 public String toString()
1270 {
1271 StringBuffer s = new StringBuffer();
1272 String nl = System.getProperty("line.separator");
1273
1274 s.append("ast_elems");
1275 s.append(nl);
1276 s.append(nl);
1277
1278 return s.toString();
1279 }
1280}