1 package fri.patterns.interpreter.parsergenerator.parsertables; 2 3 import java.util.*; 4 import fri.patterns.interpreter.parsergenerator.Token; 5 import fri.patterns.interpreter.parsergenerator.syntax.*; 6 7 14 15 class LRSyntaxNode extends SLRSyntaxNode 16 { 17 18 protected Nullable nullable; 19 20 21 protected FirstSets firstSets; 22 23 24 25 public LRSyntaxNode(Nullable nullable, FirstSets firstSets) { 26 this.nullable = nullable; 27 this.firstSets = firstSets; 28 } 29 30 31 32 protected SLRSyntaxNode createSyntaxNode() { 33 return new LRSyntaxNode(nullable, firstSets); 34 } 35 36 40 protected RuleStateItem createRuleStateItem(int ruleIndex, Rule rule) { 41 LRRuleStateItem item = new LRRuleStateItem(ruleIndex, rule); 42 addStartLookahead(item, ruleIndex); 43 return item; 44 } 45 46 47 protected void addStartLookahead(LRRuleStateItem item, int ruleIndex) { 48 if (ruleIndex == 0) { 49 List list = new ArrayList(); 50 list.add(Token.EPSILON); 51 item.addLookahead(list.iterator()); 52 } 53 } 54 55 59 protected void addRulesDerivingPendingNonTerminal(RuleStateItem itm, String nonterm, Syntax syntax, List newItems) { 60 63 LRRuleStateItem item = (LRRuleStateItem)itm; 64 List lookahead = null; 65 66 for (int i = 0; i < syntax.size(); i++) { 67 Rule rule = syntax.getRule(i); 68 69 if (rule.getNonterminal().equals(nonterm)) { 70 LRRuleStateItem rsi = (LRRuleStateItem) createRuleStateItem(i, rule); 71 72 if (lookahead == null) item.calculateLookahead( 74 lookahead = new ArrayList(), 75 nullable, 76 firstSets); 77 78 rsi.addLookahead(lookahead.iterator()); 80 if (entries.containsKey(rsi) == false) { 82 entries.put(rsi, rsi); 83 newItems.add(rsi); 84 } 85 } 86 } 87 } 88 89 90 94 protected List getNontermShiftSymbols(FirstSets firstSets, String nonterm) { 95 return null; 96 } 97 98 102 protected Iterator getReduceSymbols(FollowSets followSets, RuleStateItem item) { 103 return ((LRRuleStateItem) item).lookahead.keySet().iterator(); 104 } 105 106 107 108 109 113 protected class LRRuleStateItem extends RuleStateItem 114 { 115 Hashtable lookahead = new Hashtable(); 116 117 public LRRuleStateItem(int ruleIndex, Rule rule) { 118 super(ruleIndex, rule); 119 } 120 121 122 protected LRRuleStateItem(RuleStateItem orig) { 123 super(orig); 124 lookahead = (Hashtable) ((LRRuleStateItem) orig).lookahead.clone(); 125 } 126 127 128 protected RuleStateItem createRuleStateItem(RuleStateItem orig) { 129 return new LRRuleStateItem(orig); 130 } 131 132 136 boolean addLookahead(Iterator propagation) { 137 boolean ret = false; 140 while (propagation.hasNext()) { 141 Object la = propagation.next(); 142 143 if (lookahead.get(la) == null) { 144 lookahead.put(la, la); 145 ret = true; } 147 } 148 return ret; 149 } 150 151 160 boolean calculateLookahead(List newLookahead, Nullable nullable, FirstSets firstSets) { 161 164 for (int i = pointerPosition; i < rule.rightSize(); i++) { String symbol = rule.getRightSymbol(i); 166 167 if (Token.isTerminal(symbol)) { 168 newLookahead.add(symbol); 169 return false; } 171 else { 172 List firstSet = (List) firstSets.get(symbol); 173 174 for (int j = 0; j < firstSet.size(); j++) { 175 String la = (String ) firstSet.get(j); 176 newLookahead.add(la); 177 } 178 179 if (nullable.isNullable(symbol) == false) 180 return false; 181 } 182 } 183 184 for (Enumeration e = lookahead.keys(); e.hasMoreElements(); ) 186 newLookahead.add((String )e.nextElement()); 187 188 return true; } 190 191 192 public boolean equals(Object o) { 193 if (super.equals(o) == false) 194 return false; 195 196 LRRuleStateItem item = (LRRuleStateItem)o; 197 if (item.lookahead.equals(lookahead) == false) 198 return false; 199 200 return true; 201 } 202 203 204 public int hashCode() { 205 if (hashCache == null) { 206 int result = 0; 207 for (Enumeration e = lookahead.keys(); e.hasMoreElements(); ) 208 result ^= e.nextElement().hashCode(); 209 hashCache = new Integer (ruleIndex * 13 + pointerPosition + result); 210 } 211 return hashCache.intValue(); 212 } 213 214 215 public String toString() { 216 String s = super.toString(); 217 int i = s.lastIndexOf("->"); 218 if (i > 0) 219 s = s.substring(0, i) + "LOOKAHEAD" + hashToStr(lookahead) + " " + s.substring(i); 220 else 221 s = s + " " + hashToStr(lookahead); 222 return s; 223 } 224 225 private String hashToStr(Hashtable l) { 227 StringBuffer sb = new StringBuffer ("["); 228 for (Enumeration e = l.keys(); e.hasMoreElements(); ) { 229 String s = (String )e.nextElement(); 230 sb.append(s); 231 if (e.hasMoreElements()) 232 sb.append(", "); 233 else 234 if (l.size() == 1 && s.length() <= 0) sb.append(" "); 236 } 237 sb.append("]"); 238 return sb.toString(); 239 } 240 241 } 243 } | Popular Tags |